Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "(", "match_test", "<STR_LIT>", ")", ")", ")", "<FIXE>" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "<BUGS>", "(", "match_test", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "define_predicate", "<STR_LIT>" ]

[ "void", "PPCDispatchGroupSBHazardRecognizer", "::", "RecedeCycle", "(", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "Bottom-up scheduling not supported", "<STR_LIT>", ")", ";", "}" ]

[ "RecedeCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "bottom-up", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "VDBL", ">" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "<", "VDBL", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_concat", ":", "<" ]

[ "rtx", "m68k_legitimize_sibcall_address", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "sibcall_operand", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "VOIDmode", ")", ")", "return", "x", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", "replace_equiv_address", "(", "x", ",", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ")", ";", "}" ]

[ "Likewise", "for", "sibling", "calls", "." ]

[ "(", "DI", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_mode_attr", "td", "[", "(", "TI", "<STR_LIT>", ")" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "cc0", ")", "(", "compare", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "virtual", "void", "emitIndirectFunctionType", "(", "MCSymbol", "*", "Symbol", ",", "<FIXE>" ]

[ "virtual", "void", "emitEndFunc", "(", ")", "=", "<NUM_LIT>", ";", "<BUGS>", "virtual", "void", "emitIndirectFunctionType", "(", "StringRef", "name", ",", "<BUGE>", "SmallVectorImpl", "MVT", ">", "&", "Params", ",", "SmallVectorImpl", "MVT", ">", "&", "Results", ")", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "static", "void", "set_reg_plus_d", "PARAMS", "(", "(", "int", ",", "int", ",", "int", ",", "int", ")", ")", ";", "<FIXE>" ]

[ "static", "bool", "pa_assemble_integer", "PARAMS", "(", "(", "rtx", ",", "unsigned", "int", ",", "int", ")", ")", ";", "static", "void", "remove_useless_addtr_insns", "PARAMS", "(", "(", "rtx", ",", "int", ")", ")", ";", "static", "void", "store_reg", "PARAMS", "(", "(", "int", ",", "int", ",", "int", ")", ")", ";", "static", "void", "load_reg", "PARAMS", "(", "(", "int", ",", "int", ",", "int", ")", ")", ";", "<BUGS>", "static", "void", "set_reg_plus_d", "PARAMS", "(", "(", "int", ",", "int", ",", "int", ")", ")", ";", "<BUGE>", "static", "void", "pa_output_function_epilogue", "PARAMS", "(", "(", "FILE", "*", ",", "HOST_WIDE_INT", ")", ")", ";", "static", "int", "pa_adjust_cost", "PARAMS", "(", "(", "rtx", ",", "rtx", ",", "rtx", ",", "int", ")", ")", ";", "static", "int", "pa_adjust_priority", "PARAMS", "(", "(", "rtx", ",", "int", ")", ")", ";" ]

[ ";" ]

[ "let", "RenderMethod", "=", "<STR_LIT>" ]

[ "}" ]

[ "int", "getVarArgsFrameIndex", "(", ")", "const", "{", "return", "VarArgsFrameIndex", ";" ]

[ "}", "}", ";" ]

[ "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "GEPInfo", ".", "Imm", ")", ";", "return", "{", "{", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addReg", "(", "PtrReg", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addReg", "(", "OffsetReg", ")", ";", "}" ]

[ "CallFlags", "CFlags", "(", "CallConv", ",", "isTailCall", ",", "isVarArg", ",", "isPatchPoint", ",", "isIndirectCall", "(", "Callee", ",", "DAG", ",", "Subtarget", ",", "isPatchPoint", ")", ",", "Subtarget", ".", "is64BitELFABI", "(", ")", "&&", "any_of", "(", "Outs", ",", "[", "]", "(", "ISD", "::", "OutputArg", "Arg", ")", "{", "return", "Arg", ".", "Flags", ".", "isNest", "(", ")", ";", "}", ")", ",", "CLI", ".", "NoMerge", ")", ";" ]

[ "assert", "(", "(", "Subtarget", ".", "isUsingPCRelativeCalls", "(", ")", "||", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "&&", "<STR_LIT>", "Callee should be an llvm::Function object.", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "TCO caller: ", "<STR_LIT>", "<<", "DAG", ".", "getMachineFunction", "(", ")", ".", "getName", "(", ")", "<<", "<STR_LIT>", "\\nTCO callee: ", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "Callee", ".", "dump", "(", ")", ")", ";", "}", "}", "if", "(", "!", "isTailCall", "&&", "CB", "&&", "CB", "->", "isMustTailCall", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "failed to perform tail call elimination on a call ", "<STR_LIT>", "<STR_LIT>", "site marked musttail", "<STR_LIT>", ")", ";", "if", "(", "Subtarget", ".", "useLongCalls", "(", ")", "&&", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "&&", "!", "isTailCall", ")", "Callee", "=", "LowerGlobalAddress", "(", "Callee", ",", "DAG", ")", ";" ]

[ "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";" ]

[ "dag", "OutOperandList", "=", "(", "outs", "GPR32Opnd", ":", "$", "rt", ")", ";", "dag", "InOperandList", "=", "(", "ins", ")", ";" ]

[ "RC", ")", ";" ]

[ "bool", "PPCFastISel", "::", "processCallArgs", "(", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Args", ",", "SmallVectorImpl", "<", "unsigned", ">", "&", "ArgRegs", ",", "SmallVectorImpl", "<", "MVT", ">", "&", "ArgVTs", ",", "SmallVectorImpl", "<", "ISD", "::", "ArgFlagsTy", ">", "&", "ArgFlags", ",", "SmallVectorImpl", "<", "unsigned", ">", "&", "RegArgs", ",", "CallingConv", "::", "ID", "CC", ",", "unsigned", "&", "NumBytes", ",", "bool", "IsVarArg", ")", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "IsVarArg", ",", "*", "FuncInfo", ".", "MF", ",", "ArgLocs", ",", "*", "Context", ")", ";", "unsigned", "LinkageSize", "=", "Subtarget", "->", "getFrameLowering", "(", ")", "->", "getLinkageSize", "(", ")", ";", "CCInfo", ".", "AllocateStack", "(", "LinkageSize", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "ArgVTs", ",", "ArgFlags", ",", "CC_PPC64_ELF_FIS", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "ArgLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "I", "]", ";", "MVT", "ArgVT", "=", "ArgVTs", "[", "VA", ".", "getValNo", "(", ")", "]", ";", "if", "(", "ArgVT", ".", "isVector", "(", ")", "||", "ArgVT", ".", "getSizeInBits", "(", ")", ">", "<NUM_LIT>", "||", "ArgVT", "==", "MVT", "::", "i1", "||", "!", "VA", ".", "isRegLoc", "(", ")", "||", "VA", ".", "needsCustom", "(", ")", ")", "return", "false", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "BCvt", ")", "return", "false", ";", "}", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "NumBytes", "=", "std", "::", "max", "(", "NumBytes", ",", "LinkageSize", "+", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "unsigned", "NextGPR", "=", "PPC", "::", "X3", ";", "unsigned", "NextFPR", "=", "PPC", "::", "F1", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "ArgLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "I", "]", ";", "unsigned", "Arg", "=", "ArgRegs", "[", "VA", ".", "getValNo", "(", ")", "]", ";", "MVT", "ArgVT", "=", "ArgVTs", "[", "VA", ".", "getValNo", "(", ")", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "{", "MVT", "DestVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "(", "DestVT", "==", "MVT", "::", "i64", ")", "?", "&", "PPC", "::", "G8RCRegClass", ":", "&", "PPC", "::", "GPRCRegClass", ";", "unsigned", "TmpReg", "=", "createResultReg", "(" ]

[ "(", "match_test", "<STR_LIT>", ")", ")", ")", ")" ]

[ "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "ior", "(", "match_test", "<STR_LIT>", ")" ]

[ "int", "scalar_chain", "::", "convert", "(", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "int", "converted_insns", "=", "<NUM_LIT>", ";", "if", "(", "!", "dbg_cnt", "(", "stv_conversion", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "Converting chain #%d...\\n", "<STR_LIT>", ",", "chain_id", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "defs", ",", "<NUM_LIT>", ",", "id", ",", "bi", ")", "convert_reg", "(", "id", ")", ";", "EXECUTE_IF_AND_COMPL_IN_BITMAP", "(", "defs_conv", ",", "defs", ",", "<NUM_LIT>", ",", "id", ",", "bi", ")", "make_vector_copies", "(", "id", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "insns", ",", "<NUM_LIT>", ",", "id", ",", "bi", ")", "{", "convert_insn", "(", "DF_INSN_UID_GET", "(", "id", ")", "->", "insn", ")", ";", "converted_insns", "++", ";", "}", "return", "converted_insns", ";", "}" ]

[ "Convert", "whole", "chain", "creating", "required", "register", "conversions", "and", "copies", "." ]

[ "<STR_LIT>", ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>" ]

[ "_", "a", ";" ]

[ "return", "(", "bfloat16x8_t", ")", "_" ]

[ "}" ]

[ "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_USER_ALIGN", "(", "decl", ")", "&&", "DECL_ALIGN", "(", "decl", ")", "<", "<NUM_LIT>", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "<NUM_LIT>", ")", ")", "|=", "SYMBOL_FLAG_ALIGN1", ";" ]

[ "(", "match_operand", ":", "VECINT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VECINT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "VECINT", "(", "match_operand", ":", "VECINT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "==", "NULL_RTX", ")", "{", "rtx", "pat", ";", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "REG_POINTER", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "=", "<NUM_LIT>", ";", "pat", "=", "gen_rtx_SET", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ")", ";", "push_topmost_sequence", "(", ")" ]

[ ";" ]

[ "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "<NUM_LIT>" ]

[ "return", "expect", "(", "AsmToken", "::", "EndOfStatement", ",", "<STR_LIT>", "EOL", "<STR_LIT>", ")", ";" ]

[ "if", "(", "CurrentState", "!=", "FunctionStart", ")", "return", "error", "(", "<STR_LIT>", ".local directive should follow the start of a function", "<STR_LIT>", ",", "Lexer", ".", "getTok", "(", ")", ")", ";", "SmallVector", "<", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ">", "Locals", ";", "if", "(", "parseRegTypeList", "(", "Locals", ")", ")", "return", "true", ";", "TOut", ".", "emitLocal", "(", "Locals", ")", ";", "CurrentState", "=", "FunctionLocals", ";", "return", "expect", "(", "AsmToken", "::", "EndOfStatement", ",", "<STR_LIT>", "EOL", "<STR_LIT>", ")", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".int8", "<STR_LIT>", "||", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".int16", "<STR_LIT>", "||", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".int32", "<STR_LIT>", "||", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".int64", "<STR_LIT>", ")", "{", "if", "(", "CheckDataSection", "(", ")", ")", "return", "true", ";", "const", "MCExpr", "*", "Val", ";", "SMLoc", "End", ";", "if", "(", "Parser", ".", "parseExpression", "(", "Val", ",", "End", ")", ")", "return", "error", "(", "<STR_LIT>", "Cannot parse .int expression: ", "<STR_LIT>", ",", "Lexer", ".", "getTok", "(", ")", ")", ";", "size_t", "NumBits", "=", "<NUM_LIT>", ";", "DirectiveID", ".", "getString", "(", ")", ".", "drop_front", "(", "<NUM_LIT>", ")", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "NumBits", ")", ";", "Out", ".", "EmitValue", "(", "Val", ",", "NumBits", "/", "<NUM_LIT>", ",", "End", ")", ";", "return", "expect", "(", "AsmToken", "::", "EndOfStatement", ",", "<STR_LIT>", "EOL", "<STR_LIT>", ")", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".asciz", "<STR_LIT>", ")", "{", "if", "(", "CheckDataSection", "(", ")", ")", "return", "true", ";", "std", "::", "string", "S", ";", "if", "(", "Parser", ".", "parseEscapedString", "(", "S", ")", ")", "return", "error", "(", "<STR_LIT>", "Cannot parse string constant: ", "<STR_LIT>", ",", "Lexer", ".", "getTok", "(", ")", ")", ";", "Out", ".", "EmitBytes", "(", "StringRef", "(", "S", ".", "c_str", "(", ")", ",", "S", ".", "length", "(", ")", "+", "<NUM_LIT>", ")", ")", ";" ]

[ "<FIXS>", "sse", ",", "ssemov", ",", "sseadd", ",", "ssemul", ",", "ssecmp", ",", "ssecomi", ",", "ssecvt", ",", "ssediv", ",", "<FIXE>" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")" ]

[ "<NUM_LIT>", "]", ")", "," ]

[ "UNSPEC_CONSTTABLE_FLOAT", ")", "]", "<STR_LIT>", "{", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "CONST_DOUBLE", ")", "assemble_real", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "operands", "[" ]

[ ")", "break", ";" ]

[ "++", "SplitPoint", ";", "if", "(", "SplitPoint", "==", "BB", "->", "end", "(", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "AMDGPU", "::", "SI_KILL_TERMINATOR", ")", ")", ";", "return", "BB", ";", "}", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "SplitBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "BB", "->", "getBasicBlock", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "*", "Succ", ":", "BB", "->", "successors", "(", ")", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "*", "Succ", ")", "{", "if", "(", "!", "MI", ".", "isPHI", "(", ")" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ ")", "]" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_string", "<STR_LIT>" ]

[ "AliasResult", "TPCAAResult", "::", "alias", "(", "const", "MemoryLocation", "&", "LocA", ",", "const", "MemoryLocation", "&", "LocB", ",", "AAQueryInfo", "&", "AAQI", ")", "{", "unsigned", "asA", "=", "LocA", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "unsigned", "asB", "=", "LocB", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "AliasResult", "Result", "=", "getAliasResult", "(", "asA", ",", "asB", ")", ";", "if", "(", "Result", "==", "NoAlias", ")", "return", "Result", ";", "if", "(", "asA", "!=", "asB", "&&", "asA", "!=", "<NUM_LIT>", "&&", "asB", "!=", "<NUM_LIT>", ")", "return", "NoAlias", ";", "return", "AAResultBase", "::", "alias", "(", "LocA", ",", "LocB", ",", "AAQI", ")", ";", "}" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

[ "const", "InstrItineraryData", "&", "Itins", "=", "getTargetMachine", "(", ")", ".", "getInstrItineraryData", "(", ")", ";" ]

[ "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetInstrDesc", "&", "TID", "=", "TII", "->", "get", "(", "N", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "TID", ".", "mayLoad", "(", ")", ")", "return", "Sched", "::", "Latency", ";" ]

[ "}" ]

[ "MCAsmBackend", "*", "llvm", "::", "createFISCAsmBackend", "(", "const", "Target", "&", "T", ",", "const", "MCRegisterInfo", "&", "MRI", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ")", "{", "const", "uint8_t", "ABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "TT", ".", "getOS", "(", ")", ")", ";", "return", "new", "ELFFISCAsmBackend", "(", "T", ",", "TT", ".", "getTriple", "(", ")", ",", "ABI", ")", ";" ]

[ "<FIXS>", "return", "ix86_expand_store_builtin", "(", "CODE_FOR_sse2_movntv2di", ",", "arglist", ")", ";", "<FIXE>" ]

[ "case", "IX86_BUILTIN_MOVNTPD", ":", "return", "ix86_expand_store_builtin", "(", "CODE_FOR_sse2_movntv2df", ",", "arglist", ")", ";", "case", "IX86_BUILTIN_MOVNTDQ", ":", "<BUGS>", "return", "ix86_expand_store_builtin", "(", "CODE_FOR_sse2_movntti", ",", "arglist", ")", ";", "<BUGE>", "case", "IX86_BUILTIN_MOVNTI", ":", "return", "ix86_expand_store_builtin", "(", "CODE_FOR_sse2_movntsi", ",", "arglist", ")", ";" ]

[ "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Vd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vd32", "{", "<NUM_LIT>", "-" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<FIXE>", "<FIXS>", "if", "(", "TARGET_SSE", ")", "<FIXE>" ]

[ "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "out", ")", "DONE", "}", "<BUGS>", "else", "{", "operands", "[", "<NUM_LIT>", "]", "=", "assign_386_stack_local", "(", "HImode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "assign_386_stack_local", "(", "HImode", ",", "<NUM_LIT>", ")", "emit_i387_cw_initialization", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "operands", "[", "<NUM_LIT>", "]", "=", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "}", "<BUGE>", "}", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "use", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "]", "<BUGE>", "<STR_LIT>", "{", "<BUGS>", "if", "(", "TARGET_SSE2", ")", "<BUGE>", "{", "rtx", "out", "=", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "?", "operands", "[", "<NUM_LIT>", "]", ":", "gen_reg_rtx", "(", "SImode", ")", "emit_insn", "(", "gen_fix_truncsfsi_sse", "(", "out", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "<FIXS>", "static", "bool", "arm_vectorize_vec_perm_const", "(", "machine_mode", ",", "rtx", ",", "rtx", ",", "rtx", ",", "const", "vec_perm_indices", "&", ")", ";", "<FIXE>" ]

[ "static", "int", "arm_cortex_m_branch_cost", "(", "bool", ",", "bool", ")", ";", "static", "int", "arm_cortex_m7_branch_cost", "(", "bool", ",", "bool", ")", ";", "<BUGS>", "static", "bool", "arm_vectorize_vec_perm_const_ok", "(", "machine_mode", ",", "vec_perm_indices", ")", ";", "<BUGE>", "static", "bool", "aarch_macro_fusion_pair_p", "(", "rtx_insn", "*", ",", "rtx_insn", "*", ")", ";" ]

[ "<FIXS>", "(", "VMASKMOVPDYmr", "addr", ":", "$", "ptr", ",", "VR256", ":", "$", "mask", ",", "VR256", ":", "$", "src", ")", ">", ";", "<FIXE>", "<FIXS>", "(", "VMASKMOVPDYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ">", ";", "<FIXE>", "<FIXS>", "(", "VMASKMOVPDYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ">", ";", "<FIXE>", "<FIXS>", "(", "VBLENDVPDYrr", "VR256", ":", "$", "src0", ",", "(", "VMASKMOVPDYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ",", "<FIXE>" ]

[ "(", "VBLENDVPSYrr", "VR256", ":", "$", "src0", ",", "(", "VPMASKMOVDYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ",", "VR256", ":", "$", "mask", ")", ">", ";", "def", ":", "Pat", "(", "masked_store", "addr", ":", "$", "ptr", ",", "(", "v4i64", "VR256", ":", "$", "mask", ")", ",", "(", "v4f64", "VR256", ":", "$", "src", ")", ")", ",", "<BUGS>", "(", "VPMASKMOVQYmr", "addr", ":", "$", "ptr", ",", "VR256", ":", "$", "mask", ",", "VR256", ":", "$", "src", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "masked_store", "addr", ":", "$", "ptr", ",", "(", "v4i64", "VR256", ":", "$", "mask", ")", ",", "(", "v4i64", "VR256", ":", "$", "src", ")", ")", ",", "(", "VPMASKMOVQYmr", "addr", ":", "$", "ptr", ",", "VR256", ":", "$", "mask", ",", "VR256", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v4f64", "(", "masked_load", "addr", ":", "$", "ptr", ",", "(", "v4i64", "VR256", ":", "$", "mask", ")", ",", "undef", ")", ")", ",", "<BUGS>", "(", "VPMASKMOVQYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "v4f64", "(", "masked_load", "addr", ":", "$", "ptr", ",", "(", "v4i64", "VR256", ":", "$", "mask", ")", ",", "(", "v4f64", "immAllZerosV", ")", ")", ")", ",", "<BUGS>", "(", "VPMASKMOVQYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "v4f64", "(", "masked_load", "addr", ":", "$", "ptr", ",", "(", "v4i64", "VR256", ":", "$", "mask", ")", ",", "(", "v4f64", "VR256", ":", "$", "src0", ")", ")", ")", ",", "<BUGS>", "(", "VBLENDVPDYrr", "VR256", ":", "$", "src0", ",", "(", "VPMASKMOVQYrm", "VR256", ":", "$", "mask", ",", "addr", ":", "$", "ptr", ")", ",", "<BUGE>", "VR256", ":", "$", "mask", ")", ">", ";", "def", ":", "Pat", "(", "v4i64", "(", "masked_load", "addr", ":", "$", "ptr", ",", "(", "v4i64", "VR256", ":", "$", "mask", ")", ",", "undef", ")", ")", "," ]

[ "<FIXS>", "EVEX_CD8", "<NUM_LIT>", ",", "CD8VT1", ">", ",", "EVEX", ",", "VVVV", ",", "T_MAP5XS", ";", "<FIXE>", "<FIXS>", "EVEX_CD8", "<NUM_LIT>", ",", "CD8VT1", ">", ",", "EVEX", ",", "VVVV", ",", "XS", ";", "<FIXE>", "<FIXS>", "EVEX_CD8", "<NUM_LIT>", ",", "CD8VT1", ">", ",", "EVEX", ",", "VVVV", ",", "XD", ",", "REX_W", ";", "<FIXE>" ]

[ "multiclass", "avx512_sqrt_scalar_all", "bits", "<NUM_LIT>", ">", "opc", ",", "string", "OpcodeStr", ",", "X86SchedWriteSizes", "sched", ">", "{", "defm", "SHZ", ":", "avx512_sqrt_scalar", "opc", ",", "OpcodeStr", "#", "<STR_LIT>", ",", "sched", ".", "PH", ".", "Scl", ",", "f16x_info", ",", "NAME", "#", "<STR_LIT>", ",", "HasFP16", ">", ",", "<BUGS>", "EVEX_CD8", "<NUM_LIT>", ",", "CD8VT1", ">", ",", "EVEX_4V", ",", "T_MAP5XS", ";", "<BUGE>", "defm", "SSZ", ":", "avx512_sqrt_scalar", "opc", ",", "OpcodeStr", "#", "<STR_LIT>", ",", "sched", ".", "PS", ".", "Scl", ",", "f32x_info", ",", "NAME", "#", "<STR_LIT>", ">", ",", "<BUGS>", "EVEX_CD8", "<NUM_LIT>", ",", "CD8VT1", ">", ",", "EVEX_4V", ",", "XS", ";", "<BUGE>", "defm", "SDZ", ":", "avx512_sqrt_scalar", "opc", ",", "OpcodeStr", "#", "<STR_LIT>", ",", "sched", ".", "PD", ".", "Scl", ",", "f64x_info", ",", "NAME", "#", "<STR_LIT>", ">", ",", "<BUGS>", "EVEX_CD8", "<NUM_LIT>", ",", "CD8VT1", ">", ",", "EVEX_4V", ",", "XD", ",", "REX_W", ";", "<BUGE>", "}", "defm", "VSQRT", ":", "avx512_sqrt_packed_all", "<NUM_LIT>", ",", "<STR_LIT>", ",", "SchedWriteFSqrtSizes", ">", "," ]

[ ")", ";" ]

[ "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".frame", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".set", "<STR_LIT>", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".fmask", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".mask", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".nan", "<STR_LIT>", ")", "return", "parseDirectiveNaN", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".gpword", "<STR_LIT>", ")", "{", "parseDirectiveGpWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".gpdword", "<STR_LIT>", ")", "{", "parseDirectiveGpDWord", "(" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>" ]

[ "return", "<NUM_LIT>", ";" ]

[ "if", "(", "GET_MODE_SIZE", "(", "m1", ")", "==", "GET_MODE_SIZE", "(", "m2", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "m1", "==", "QImode", "||", "m2", "==", "QImode", ")", "return", "<NUM_LIT>", ";" ]

[ "override", "{" ]

[ "StringRef", "getPassName", "(", ")", "const" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "rt", ";", "bits", "<", "<NUM_LIT>", ">", "imm10", ";", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm10", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "funct", ";" ]

[ "->", "getSubtargetImpl", "(", "F", ")", "->", "getFeatureBits", "(", ")", ";" ]

[ "FeatureBitset", "Features", "=", "WasmTM", "->", "getSubtargetImpl", "(", "std", "::", "string", "(", "WasmTM", "->", "getTargetCPU", "(", ")", ")", ",", "std", "::", "string", "(", "WasmTM", "->", "getTargetFeatureString", "(", ")", ")", ")", "->", "getFeatureBits", "(", ")", ";", "for", "(", "auto", "&", "F", ":", "M", ")", "Features", "|=", "WasmTM" ]

[ "<FIXS>", "let", "SubtargetPredicate", "=", "UseRealTrue16Insts", "in", "<FIXE>" ]

[ "def", ":", "ClampPat", "V_MAX_F64_e64", ",", "f64", ">", ";", "let", "SubtargetPredicate", "=", "NotHasTrue16BitInsts", "indef", ":", "ClampPat", "V_MAX_F16_e64", ",", "f16", ">", ";", "<BUGS>", "let", "SubtargetPredicate", "=", "HasTrue16BitInsts", "in", "<BUGE>", "def", ":", "ClampPat", "V_MAX_F16_t16_e64", ",", "f16", ">", ";", "let", "SubtargetPredicate", "=", "HasVOP3PInsts", "in", "{", "def", ":", "GCNPat" ]

[ "(", "I", ")", ";" ]

[ "if", "(", "uint64_t", "CalleeAmt", "=", "TII", ".", "getFramePoppedByCallee", "(", "*", "I", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CalleeAmt", ")", ")", ";", "}", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase" ]

[ "<NUM_LIT>", "]", ">", ";" ]

[ "def", "V18", ":", "TPCReg", "<", "<STR_LIT>", ",", "<NUM_LIT>", ">", ",", "DwarfRegNum", "<", "[" ]

[ "&", "Operands", ")", "{" ]

[ "OperandMatchResultTy", "AMDGPUAsmParser", "::", "parseBoolReg", "(", "OperandVector" ]

[ "printOperand", "(", "MI", ",", "OpNo", "+", "<NUM_LIT>", ",", "O", ")", ";" ]

[ "void", "AMDGPUInstPrinter", "::", "printOperandAndMods", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "unsigned", "InputModifiers", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ";", "if", "(", "InputModifiers", "&", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", "-", "<STR_LIT>", ";", "if", "(", "InputModifiers", "&", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", "|", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "plus", ":", "SI", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";" ]

[ "def", "BWWriteResGroup43", ":", "SchedWriteRes", "<", "[", "BWPort0", ",", "BWPort4", ",", "BWPort237", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>" ]

[ ",", "Result", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";" ]

[ "SDValue", "CPIdx1", "=", "DAG", ".", "getConstantPool", "(", "C1", ",", "PtrVT", ",", "<NUM_LIT>", ")", ";", "SDValue", "XR1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v2i64", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "CLod0", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "v4i32", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CPIdx0", ",", "MachinePointerInfo", "::", "getConstantPool", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ",", "<NUM_LIT>", ")", ";", "SDValue", "Unpck1", "=", "getUnpackl", "(", "DAG", ",", "dl", ",", "MVT", "::", "v4i32", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v4i32", ",", "XR1", ")", ",", "CLod0", ")", ";", "SDValue", "CLod1", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "v2f64", ",", "dl", ",", "CLod0", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "CPIdx1", ",", "MachinePointerInfo", "::", "getConstantPool", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ",", "<NUM_LIT>", ")", ";", "SDValue", "XR2F", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v2f64", ",", "Unpck1", ")", ";", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "MVT", "::", "v2f64", ",", "XR2F", ",", "CLod1", ")", ";", "SDValue", "Result", ";", "if", "(", "Subtarget", ".", "hasSSE3", "(", ")", ")", "{", "Result", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Sub", ",", "Sub", ")", ";", "}", "else", "{", "SDValue", "Shuffle", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v2f64", ",", "dl", ",", "Sub", ",", "Sub", ",", "{", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FADD", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Shuffle", ",", "Sub", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "f64" ]

[ ":", "<STR_LIT>", "<STR_LIT>", ")", ";" ]

[ "}", "else", "{", "fputs", "(", "<STR_LIT>", "\\tbcl 20,31,1f\\n\\t.long ", "<STR_LIT>", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fputs", "(", "<STR_LIT>", "-.\\n1:", "<STR_LIT>", ",", "file", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tmflr %s\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "}", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tlwz %s,0(%s)\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd %s,%s,%s\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tlis %s,", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fputs", "(", "<STR_LIT>", "@ha\\n", "<STR_LIT>", ",", "file", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tstw %s,4(%s)\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tla %s,", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "@l(%s)\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "}", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tbl %s%s\\n", "<STR_LIT>", ",", "RS6000_MCOUNT", ",", "flag_pic", "?", "<STR_LIT>", "@plt", "<STR_LIT>" ]

[ ";" ]

[ "MinimizeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "I", ")", ";", "return", "Modified" ]

[ "}" ]

[ "setBundleNoShuf", "(", "MachineBasicBlock", "::", "instr_iterator", "MIB", ")", "const", "{", "assert", "(", "MIB", "->", "isBundle", "(", ")", ")", ";", "MachineOperand", "&", "Operand", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Operand", ".", "isImm", "(", ")", ")", "Operand", ".", "setImm", "(", "Operand", ".", "getImm", "(", ")", "|", "memShufDisabledMask", ")", ";", "else", "MIB", "->", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "memShufDisabledMask", ")", ")", ";" ]

[ ")", ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const_string", "<STR_LIT>" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "QI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>" ]

[ "let", "isFP", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "if", "(", "CurrUser", "&&", "!", "isa", "CallInst", ">", "(", "Curr", ")", "&&", "!", "isa", "Constant", ">", "(", "Curr", ")", ")", "<FIXE>" ]

[ "Value", "*", "Curr", "=", "WorkList", ".", "back", "(", ")", ";", "WorkList", ".", "pop_back", "(", ")", ";", "auto", "*", "CurrUser", "=", "dyn_cast", "User", ">", "(", "Curr", ")", ";", "<BUGS>", "if", "(", "CurrUser", "&&", "!", "isa", "CallInst", ">", "(", "Curr", ")", ")", "<BUGE>", "for", "(", "auto", "&", "Op", ":", "CurrUser", "->", "operands", "(", ")", ")", "if", "(", "Defs", ".", "insert", "(", "Op", ")", ".", "second", ")", "WorkList", ".", "push_back", "(", "Op", ")", ";" ]

[ "<FIXS>", "or", "store", ".", "So", "DWARF", "information", "needs", "fixing", "in", "little", "endian", "(", "unless", "<FIXE>" ]

[ "}", "rtxsh_dwarf_register_span", "(", "rtx", "reg", ")" ]

[ "constrainSelectedInstRegOperands", "(", "*", "Dup", ",", "TII", ",", "TRI", ",", "RBI", ")", ";" ]

[ "}", "bool", "IsFP", "=", "ScalarRB", "->", "getID", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "static", "const", "unsigned", "OpcTable", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", "=", "{", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ";", "unsigned", "Opc", "=", "OpcTable", "[", "IsFP", "]", "[", "EltTy", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", "]", ";", "if", "(", "IsFP", ")", "{", "MachineInstr", "*", "Widen", "=", "emitScalarToVector", "(", "EltTy", ".", "getSizeInBits", "(", ")", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ",", "ScalarReg", ",", "MIB", ")", ";", "if", "(", "!", "Widen", ")", "return", "false", ";", "ScalarReg", "=", "Widen", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "auto", "Dup", "=", "MIB", ".", "buildInstr", "(", "Opc", ",", "{", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "}", ",", "{", "ScalarReg", "}", ")", ";", "if", "(", "IsFP", ")", "Dup", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "Cand", ".", "setBest", "(", "TopCand", ")", ";", "<FIXE>" ]

[ "TopCand", ".", "Reason", "=", "NoCand", ";", "GenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TopCand", ",", "nullptr", ")", ";", "if", "(", "TopCand", ".", "Reason", "!=", "NoCand", ")", "{", "<BUGS>", "Cand", ".", "setBest", "(", "TopCand", ")", ";", "<BUGE>", "}", "else", "{", "TopCand", ".", "Reason", "=", "TopReason", ";", "}" ]

[ ")", ")", "]" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VMLS_LANE", ")", ")", "]", "<STR_LIT>", "{", "return", "<STR_LIT>", "}", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_test", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")" ]

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")" ]

[ "(", "define_memory_constraint", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "machine_mode", "vmode", ";", "<FIXE>" ]

[ "{", "rtx", "target", ",", "op0", ",", "op1", ";", "unsigned", "char", "perm", "[", "MAX_VECT_LEN", "]", ";", "<BUGS>", "enum", "machine_mode", "vmode", ";", "<BUGE>", "unsigned", "char", "nelt", ";", "bool", "one_vector_p", ";", "bool", "testing_p", ";" ]

[ "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "(", "define_function_unit", "<STR_LIT>", "<NUM_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";" ]

[ "let", "mayStore", "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Zt", ";", "bits", "<", "<NUM_LIT>", ">", "imm4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "msz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "esz", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zt", ";" ]

[ "bool", "AArch64TargetLowering", "::", "lowerInterleavedLoad", "(", "LoadInst", "*", "LI", ",", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "<NUM_LIT>", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "<STR_LIT>", "Invalid interleave factor", "<STR_LIT>", ")", ";", "assert", "(", "!", "Shuffles", ".", "empty", "(", ")", "&&", "<STR_LIT>", "Empty shufflevector input", "<STR_LIT>", ")", ";", "assert", "(", "Shuffles", ".", "size", "(", ")", "==", "Indices", ".", "size", "(", ")", "&&", "<STR_LIT>", "Unmatched number of shufflevectors and indices", "<STR_LIT>", ")", ";", "if", "(", "Factor", ">", "<NUM_LIT>", ")", "return", "false", ";", "const", "DataLayout", "&", "DL", "=", "LI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "VectorType", "*", "VecTy", "=", "Shuffles", "[", "<NUM_LIT>", "]", "->", "getType", "(", ")", ";", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "VecSize", "!=", "<NUM_LIT>", "&&", "VecSize", "!=", "<NUM_LIT>", ")", ")", "return", "false", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "VecTy", "=", "VectorType", "::", "get", "(", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ",", "VecTy", "->", "getVectorNumElements", "(", ")", ")", ";", "Type", "*", "PtrTy", "=", "VecTy", "->", "getPointerTo", "(", "LI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Type", "*", "Tys", "[", "<NUM_LIT>", "]", "=", "{", "VecTy", ",", "PtrTy", "}", ";", "static", "const", "Intrinsic", "::", "ID", "LoadInts", "[", "<NUM_LIT>", "]", "=", "{", "Intrinsic", "::", "aarch64_neon_ld2", ",", "Intrinsic", "::", "aarch64_neon_ld3", ",", "Intrinsic", "::", "aarch64_neon_ld4", "}", ";", "Function", "*", "LdNFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "LI", "->", "getModule", "(", ")", ",", "LoadInts", "[", "Factor", "-", "<NUM_LIT>", "]", ",", "Tys", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "LI", ")", ";", "Value", "*", "Ptr", "=", "Builder", ".", "CreateBitCast", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "PtrTy", ")", ";", "CallInst", "*", "LdN", "=", "Builder", ".", "CreateCall", "(", "LdNFunc", ",", "Ptr", ",", "<STR_LIT>", "ldN", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Shuffles", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ShuffleVectorInst", "*", "SVI", "=", "Shuffles", "[", "i", "]", ";", "unsigned", "Index", "=", "Indices", "[", "i", "]", ";", "Value", "*", "SubVec", "=", "Builder", ".", "CreateExtractValue", "(", "LdN", ",", "Index", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "SubVec", "=", "Builder", ".", "CreateIntToPtr", "(", "SubVec", ",", "SVI", "->", "getType", "(", ")", ")", ";", "SVI", "->", "replaceAllUsesWith", "(", "SubVec", ")", ";", "}", "return", "true", ";", "}" ]

[ "Lower", "interleaved", "load", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "DecodeStatus", "AArch64Disassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "CommentStream", "=", "&", "cs", ";", "uint8_t", "bytes", "[", "<NUM_LIT>", "]", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "<NUM_LIT>", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "insn", "=", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", ";", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableA6432", ",", "MI", ",", "insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "<FIXS>", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "<FIXE>", "<FIXS>", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "<FIXE>" ]

[ "if", "(", "isFPCmp", ")", "{", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ")", "<BUGS>", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "<BUGE>", ".", "addMBB", "(", "sinkMBB", ")", ";", "}", "else", "{", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ")", "<BUGS>", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "<BUGE>", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "}" ]

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nregs", ";", "i", "++", ")", "{" ]

[ "int", "nregs", "=", "size", "/", "base_mode_size", ",", "i", ";", "rtx", "regs", ";", "regs", "=", "gen_rtx_PARALLEL", "(", "BLKmode", ",", "rtvec_alloc", "(", "nregs", ")", ")", ";" ]

[ "static", "void", "dump_minipool", "(", "rtx_insn", "*", "scan", ")", "{", "Mnode", "*", "mp", ";", "Mnode", "*", "nmp", ";", "int", "align64", "=", "<NUM_LIT>", ";", "if", "(", "ARM_DOUBLEWORD_ALIGN", ")", "for", "(", "mp", "=", "minipool_vector_head", ";", "mp", "!=", "NULL", ";", "mp", "=", "mp", "->", "next", ")", "if", "(", "mp", "->", "refcount", ">", "<NUM_LIT>", "&&", "mp", "->", "fix_size", ">=", "<NUM_LIT>", ")", "{", "align64", "=", "<NUM_LIT>", ";", "break", ";", "}", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "<STR_LIT>", ";; Emitting minipool after insn %u; address %ld; align %d (bytes)\\n", "<STR_LIT>", ",", "INSN_UID", "(", "scan", ")", ",", "(", "unsigned", "long", ")", "minipool_barrier", "->", "address", ",", "align64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "scan", "=", "emit_label_after", "(", "gen_label_rtx", "(", ")", ",", "scan", ")", ";", "scan", "=", "emit_insn_after", "(", "align64", "?", "gen_align_8", "(", ")", ":", "gen_align_4", "(", ")", ",", "scan", ")", ";", "scan", "=", "emit_label_after", "(", "minipool_vector_label", ",", "scan", ")", ";", "for", "(", "mp", "=", "minipool_vector_head", ";", "mp", "!=", "NULL", ";", "mp", "=", "nmp", ")", "{", "if", "(", "mp", "->", "refcount", ">", "<NUM_LIT>", ")", "{", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "<STR_LIT>", ";; Offset %u, min %ld, max %ld ", "<STR_LIT>", ",", "(", "unsigned", ")", "mp", "->", "offset", ",", "(", "unsigned", "long", ")", "mp", "->", "min_address", ",", "(", "unsigned", "long", ")", "mp", "->", "max_address", ")", ";", "arm_print_value", "(", "dump_file", ",", "mp", "->", "value", ")", ";", "fputc", "(", "'", "\\n", "'", ",", "dump_file", ")", ";", "}", "switch", "(", "GET_MODE_SIZE", "(", "mp", "->", "mode", ")", ")", "{", "case", "<NUM_LIT>", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_1", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_2", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_4", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_8", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_16", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "nmp", "=", "mp", "->", "next", ";", "free", "(", "mp", ")", ";", "}", "minipool_vector_head", "=", "minipool_vector_tail", "=", "NULL", ";", "scan", "=", "emit_insn_after", "(", "gen_consttable_end", "(", ")", ",", "scan", ")", ";", "scan", "=", "emit_barrier_after", "(", "scan", ")", ";", "}" ]

[ "Output", "the", "literal", "table" ]

[ "<FIXS>", "if", "(", "!", "MI", ".", "isCommutable", "(", ")", "||", "!", "TII", "->", "commuteInstruction", "(", "MI", ")", "||", "<FIXE>" ]

[ "if", "(", "!", "canShrink", "(", "MI", ",", "TII", ",", "TRI", ",", "MRI", ")", ")", "{", "<BUGS>", "if", "(", "!", "MI", ".", "isCommutable", "(", ")", "||", "!", "TII", "->", "commuteInstruction", "(", "&", "MI", ")", "||", "<BUGE>", "!", "canShrink", "(", "MI", ",", "TII", ",", "TRI", ",", "MRI", ")", ")", "continue", ";", "}" ]

[ "static", "void", "ix86_init_builtins_va_builtins_abi", "(", "void", ")", "{", "tree", "ms_va_ref", ",", "sysv_va_ref", ";", "tree", "fnvoid_va_end_ms", ",", "fnvoid_va_end_sysv", ";", "tree", "fnvoid_va_start_ms", ",", "fnvoid_va_start_sysv", ";", "tree", "fnvoid_va_copy_ms", ",", "fnvoid_va_copy_sysv", ";", "tree", "fnattr_ms", "=", "NULL_TREE", ",", "fnattr_sysv", "=", "NULL_TREE", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", ";", "fnattr_ms", "=", "build_tree_list", "(", "get_identifier", "(", "<STR_LIT>", "ms_abi", "<STR_LIT>", ")", ",", "NULL_TREE", ")", ";", "fnattr_sysv", "=", "build_tree_list", "(", "get_identifier", "(", "<STR_LIT>", "sysv_abi", "<STR_LIT>", ")", ",", "NULL_TREE", ")", ";", "ms_va_ref", "=", "build_reference_type", "(", "ms_va_list_type_node", ")", ";", "sysv_va_ref", "=", "build_pointer_type", "(", "TREE_TYPE", "(", "sysv_va_list_type_node", ")", ")", ";", "fnvoid_va_end_ms", "=", "build_function_type_list", "(", "void_type_node", ",", "ms_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_start_ms", "=", "build_varargs_function_type_list", "(", "void_type_node", ",", "ms_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_end_sysv", "=", "build_function_type_list", "(", "void_type_node", ",", "sysv_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_start_sysv", "=", "build_varargs_function_type_list", "(", "void_type_node", ",", "sysv_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_copy_ms", "=", "build_function_type_list", "(", "void_type_node", ",", "ms_va_ref", ",", "ms_va_list_type_node", ",", "NULL_TREE", ")", ";", "fnvoid_va_copy_sysv", "=", "build_function_type_list", "(", "void_type_node", ",", "sysv_va_ref", ",", "sysv_va_ref", ",", "NULL_TREE", ")", ";", "add_builtin_function", "(", "<STR_LIT>", "__builtin_ms_va_start", "<STR_LIT>", ",", "fnvoid_va_start_ms", ",", "BUILT_IN_VA_START", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_ms", ")", ";", "add_builtin_function", "(", "<STR_LIT>", "__builtin_ms_va_end", "<STR_LIT>", ",", "fnvoid_va_end_ms", ",", "BUILT_IN_VA_END", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_ms", ")", ";", "add_builtin_function", "(", "<STR_LIT>", "__builtin_ms_va_copy", "<STR_LIT>", ",", "fnvoid_va_copy_ms", ",", "BUILT_IN_VA_COPY", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_ms", ")", ";", "add_builtin_function", "(", "<STR_LIT>", "__builtin_sysv_va_start", "<STR_LIT>", ",", "fnvoid_va_start_sysv", ",", "BUILT_IN_VA_START", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_sysv", ")", ";", "add_builtin_function", "(", "<STR_LIT>", "__builtin_sysv_va_end", "<STR_LIT>", ",", "fnvoid_va_end_sysv", ",", "BUILT_IN_VA_END", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_sysv", ")", ";", "add_builtin_function", "(", "<STR_LIT>", "__builtin_sysv_va_copy", "<STR_LIT>", ",", "fnvoid_va_copy_sysv", ",", "BUILT_IN_VA_COPY", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_sysv", ")", ";", "}" ]

[ "Internal", "method", "for", "ix86_init_builtins", "." ]

[ "}" ]

[ "let", "POP_COUNT", "=", "<NUM_LIT>", ";", "let", "ADDR", "=", "<NUM_LIT>", ";", "let", "END_OF_PROGRAM", "=", "<NUM_LIT>", ";" ]

[ "::", "None", ";" ]

[ "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "(", "Subtarget", ".", "hasSSE1", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "return", "AtomicExpansionKind" ]

[ "(", "any_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "truncate", ":", "SI", "(", "ashiftrt", ":", "DI", "(", "mult", ":", "DI", "(", "any_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "case", "UNSPEC_FRINTN", ":" ]

[ "case", "UNSPEC_FRINTZ", ":", "case", "UNSPEC_FRINTP", ":", "case", "UNSPEC_FRINTM", ":", "case", "UNSPEC_FRINTA", ":" ]

[ ")", ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", ";", "O", "<<", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "CC", ")" ]

[ "}" ]

[ "const", "MMIXSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";" ]

[ "DONE" ]

[ "if", "(", "TARGET_NEON", ")", "{", "emit_insn", "(", "gen_negdi2_neon", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "src", ")", ")", ")", ")", "]", ">", ",", "VEX", ",", "Sched", "<", "[", "WriteCvtPD2ILd", "]", ">", ",", "VEX_WIG", ";" ]

[ "def", "VCVTPD2DQrm", ":", "SDI", "<", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "f128mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "v4i32", "(", "X86cvtp2Int", "(", "loadv2f64", "addr", ":", "$" ]

[ "(", ")", ";" ]

[ "bool", "X86TargetLowering", "::", "shouldUseStrictFP_TO_INT", "(", "EVT", "FpVT", ",", "EVT", "IntVT", ",", "bool", "IsSigned", ")", "const", "{", "return", "!", "IsSigned", "&&", "FpVT", "==", "MVT", "::", "f80", "&&", "Subtarget", ".", "hasCMov" ]

[ "}" ]

[ "bool", "isTargetWin32", "(", ")", "const", "{", "return", "!", "In64BitMode", "&&", "(", "isTargetCygMing", "(", ")", "||", "isTargetWindows", "(", ")", ")", ";" ]

[ "<FIXS>", "||", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "func_desc", ")", ")", ")", "<FIXE>", "<FIXS>", "rtx", "stack_toc_offset", "=", "GEN_INT", "(", "RS6000_TOC_SAVE_SLOT", ")", ";", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "func_desc", ")", "!=", "SYMBOL_REF", "<BUGS>", "||", "!", "SYMBOL_REF_FUNCTION_P", "(", "func_desc", ")", ")", "<BUGE>", "{", "rtx", "stack_ptr", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "<BUGS>", "rtx", "stack_toc_offset", "=", "GEN_INT", "(", "<NUM_LIT>", "*", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ";", "<BUGE>", "rtx", "stack_toc_mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_ptr", ",", "stack_toc_offset", ")", ")", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "if", "(", "TARGET_A16", ")", "flag_no_function_cse" ]

[ "BaseReg", ";" ]

[ "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** ", "<STR_LIT>", "<<", "getPassName", "(", ")", "<<", "<STR_LIT>", ": ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Skipping pass: no machine model present.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Unpairing store ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=" ]

[ ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ ")", ";" ]

[ "MCAsmBackend", "*", "llvm", "::", "createBPFAsmBackend", "(", "const", "Target", "&", "T", ",", "const", "MCRegisterInfo", "&", "MRI", ",", "StringRef", "TT", ",", "StringRef", "CPU", ")", "{", "return", "new", "BPFAsmBackend", "(" ]

[ ")", "]", ")" ]

[ "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad" ]

[ "let", "Predicates", "=", "[", "HasFullFP16", "]", ";" ]

[ "def", "Hi", ":", "BaseFPMoveImmediate", "<", "FPR16", ",", "fpimm16", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "return", "BaseT", "::", "getCmpSelInstrCost", "(", "Opcode", ",", "ValTy", ",", "CondTy", ",", "VecPred", ",", "CostKind", ",", "I", ")", ";", "<FIXE>" ]

[ "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "SSE1CostTbl", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "(", "ExtraCost", "+", "Entry", "->", "Cost", ")", ";", "<BUGS>", "return", "BaseT", "::", "getCmpSelInstrCost", "(", "Opcode", ",", "ValTy", ",", "CondTy", ",", "CostKind", ",", "I", ")", ";", "<BUGE>", "}", "unsigned", "X86TTIImpl", "::", "getAtomicMemIntrinsicMaxElementSize", "(", ")", "const", "{", "return", "<NUM_LIT>", ";", "}" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]" ]

[ "(", "mult", ":", "TI", "(", "ANY_EXTEND", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "V", ")", ")", "{" ]

[ "if", "(", "const", "LoadInst", "*", "Load", "=", "dyn_cast", "<", "LoadInst", ">", "(", "V", ")", ")", "return", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ";", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "V", ")", "||", "isa", "<", "AtomicCmpXchgInst", ">", "(", "V", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", ";", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(" ]

[ "}" ]

[ "const", "uint32_t", "*", "TeakRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_RegMask", ";" ]