Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "return", "false", ";" ]

[ "static", "bool", "isSpvIntrinsic", "(", "MachineInstr", "&", "MI", ",", "Intrinsic", "::", "ID", "IntrinsicID", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", "&&", "MI", ".", "getIntrinsicID", "(", ")", "==", "IntrinsicID", ")", "return", "true", ";" ]

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

[ "case", "Intrinsic", "::", "wasm_lsda", ":", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "MVT", "PtrVT", "=", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "auto", "&", "Context", "=", "MF", ".", "getMMI", "(", ")", ".", "getContext", "(", ")", ";", "MCSymbol", "*", "S", "=", "Context", ".", "getOrCreateSymbol", "(", "Twine", "(", "<STR_LIT>", "GCC_except_table", "<STR_LIT>", ")", "+", "Twine", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "DAG", ".", "getMCSymbol", "(", "S", ",", "PtrVT", ")", ")", ";", "}", "case", "Intrinsic", "::", "wasm_throw", ":", "{", "SDValue", "SymNode", "=", "getCppExceptionSymNode", "(", "Op", ",", "<NUM_LIT>", ",", "DAG", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "SymNode", ",", "Op", ".", "getOperand" ]

[ ",", "Ty", ")", ";" ]

[ "int", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "return", "getIntImmCost", "(", "Imm" ]

[ ")", ";" ]

[ "void", "PPCSubtarget", "::", "initSubtargetFeatures", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "std", "::", "string", "(", "CPU", ")", ";", "if", "(", "CPUName", ".", "empty", "(", ")", "||", "CPU", "==", "<STR_LIT>", "generic", "<STR_LIT>", ")", "{", "if", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", ")", "CPUName", "=", "<STR_LIT>", "ppc64le", "<STR_LIT>", ";", "else", "if", "(", "TargetTriple", ".", "getSubArch", "(", ")", "==", "Triple", "::", "PPCSubArch_spe", ")", "CPUName", "=", "<STR_LIT>", "e500", "<STR_LIT>", ";", "else", "CPUName", "=", "<STR_LIT>", "generic", "<STR_LIT>", ";", "}", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "if", "(", "IsPPC64", "&&", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "true", ";", "if", "(", "(", "TargetTriple", ".", "isOSFreeBSD", "(", ")", "&&", "TargetTriple", ".", "getOSMajorVersion", "(", ")", ">=", "<NUM_LIT>", ")", "||", "TargetTriple", ".", "isOSNetBSD", "(", ")", "||", "TargetTriple", ".", "isOSOpenBSD", "(", ")", "||", "TargetTriple", ".", "isMusl", "(", ")", ")", "SecurePlt", "=", "true", ";", "if", "(", "HasSPE", "&&", "IsPPC64", ")", "report_fatal_error", "(", "<STR_LIT>", "SPE is only supported for 32-bit targets.\\n", "<STR_LIT>", ",", "false" ]

[ "if", "(", "!", "Functions", ".", "empty", "(", ")", ")", "Changed", "|=", "optimizeFunctions", "(", "Functions", ")", ";" ]

[ "for", "(", "auto", "&", "F", ":", "M", ".", "getFunctionList", "(", ")", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "switch", "(", "F", ".", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "vector_extract", ":", "case", "Intrinsic", "::", "vector_insert", ":", "case", "Intrinsic", "::", "aarch64_sve_ptrue", ":", "for", "(", "User", "*", "U", ":", "F", ".", "users", "(", ")", ")", "Functions", ".", "insert", "(", "cast", "<", "Instruction", ">", "(", "U", ")", "->", "getFunction", "(", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}" ]

[ "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{" ]

[ "unsigned", "TeeRISCELFObjectWriter", "::", "GetRelocType", "(", "const", "MCValue", "&", "Target", ",", "const", "MCFixup", "&", "Fixup", ",", "bool", "IsPCRel", ",", "bool", "IsRelocWithSymbol", ",", "int64_t", "Addend", ")", "const", "{", "unsigned", "Type", ";", "if", "(", "IsPCRel", ")", "{" ]

[ "<FIXS>", "let", "Defs", "=", "[", "ESP", ",", "EFLAGS", "]", ",", "Uses", "=", "[", "ESP", "]", ",", "mayLoad", "=", "<NUM_LIT>", ",", "neverHasSideEffects", "=", "<NUM_LIT>", "in", "{", "def", "POPF", ":", "I", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "OpSize", ";", "def", "POPFD", ":", "I", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "}", "let", "Defs", "=", "[", "ESP", "]", ",", "Uses", "=", "[", "ESP", ",", "EFLAGS", "]", ",", "mayStore", "=", "<NUM_LIT>", ",", "neverHasSideEffects", "=", "<NUM_LIT>", "in", "{", "def", "PUSHF", ":", "I", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "OpSize", ";", "def", "PUSHFD", ":", "I", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "}", "<FIXE>" ]

[ "<STR_LIT>", ",", "[", "]", ">", ";", "}", "<BUGS>", "let", "Defs", "=", "[", "ESP", ",", "EFLAGS", "]", ",", "Uses", "=", "[", "ESP", "]", ",", "mayLoad", "=", "<NUM_LIT>", ",", "neverHasSideEffects", "=", "<NUM_LIT>", "indef", "POPFD", ":", "I", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "let", "Defs", "=", "[", "ESP", "]", ",", "Uses", "=", "[", "ESP", ",", "EFLAGS", "]", ",", "mayStore", "=", "<NUM_LIT>", ",", "neverHasSideEffects", "=", "<NUM_LIT>", "indef", "PUSHFD", ":", "I", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "let", "isTwoAddress", "=", "<NUM_LIT>", "in", "def", "BSWAP32r", ":", "I", "<NUM_LIT>", ",", "AddRegFrm", "," ]

[ "addPreRegAlloc", "(", ")", "{" ]

[ "bool", "AMDGPUPassConfig", "::" ]

[ ":", "<", "VDBLW", ">" ]

[ "[", "(", "set", "(", "match_operand", ":", "<", "VDBLW", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "<", "VDBLW", ">", "(", "zero_extend" ]

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

[ "def", "J2_jumpr", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_d5b7b0c1", ",", "TypeJ", ">", ",", "Enc_ecbcc8", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";" ]

[ "NO_REGS", ";" ]

[ "switch", "(", "c", ")", "{", "case", "'", "a", "'", ":", "return", "MAC_REGS", ";", "case", "'", "c", "'", ":", "return", "COUNTER_REGS", ";", "case", "'", "d", "'", ":", "if", "(", "!", "flag_omit_frame_pointer", "&&", "!", "reload_completed", ")", "return" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "OutOfSlotData", "=", "<NUM_LIT>", ";" ]

[ "=", "PPC", "::", "OR8", ";" ]

[ "DestReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "PPC", "::", "VSLRCRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "PPC", "::", "sub_64", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "VSXSelfCopyCrash", "&&", "DestReg", "==", "SuperReg", ")", "llvm_unreachable", "(", "<STR_LIT>", "nop VSX copy", "<STR_LIT>", ")", ";", "SrcReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "PPC", "::", "VSHRCRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "PPC", "::", "sub_128", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "VSXSelfCopyCrash", "&&", "DestReg", "==", "SuperReg", ")", "llvm_unreachable", "(", "<STR_LIT>", "nop VSX copy", "<STR_LIT>", ")", ";", "SrcReg", "=", "SuperReg", ";", "}", "unsigned", "Opc", ";", "if", "(", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR", ";", "else", "if", "(", "PPC", "::", "G8RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc" ]

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

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

[ "g", ",", "true", ")", ";" ]

[ "tree", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "lhs_type", "=", "TREE_TYPE", "(", "lhs", ")", ";", "int", "n_elts", "=", "TYPE_VECTOR_SUBPARTS", "(", "lhs_type", ")", ";", "tree", "permute_type", ";", "permute_type", "=", "map_to_integral_tree_type", "(", "lhs_type", ")", ";", "tree_vector_builder", "elts", "(", "permute_type", ",", "VECTOR_CST_NELTS", "(", "arg0", ")", ",", "<NUM_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_elts", "/", "<NUM_LIT>", ";", "i", "++", ")", "{", "elts", ".", "safe_push", "(", "build_int_cst", "(", "TREE_TYPE", "(", "permute_type", ")", ",", "<NUM_LIT>", "*", "i", "+", "use_odd", ")", ")", ";", "elts", ".", "safe_push", "(", "build_int_cst", "(", "TREE_TYPE", "(", "permute_type", ")", ",", "<NUM_LIT>", "*", "i", "+", "use_odd", "+", "n_elts", ")", ")", ";", "}", "tree", "permute", "=", "elts", ".", "build", "(", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "VEC_PERM_EXPR", ",", "arg0", ",", "arg1", ",", "permute", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", "," ]

[ "<STR_LIT>", ")" ]

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

[ "op", "[", "arg_count", "]", "=", "convert_memory_address", "(", "Pmode", ",", "op", "[", "arg_count", "]", ")", ";" ]

[ "arg_count", "++", ";", "idx", "=", "arg_count", "-", "!", "nonvoid", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "idx", "]", ";", "op", "[", "arg_count", "]", "=", "expand_normal", "(", "arg", ")", ";", "if", "(", "(", "code", ">=", "SPARC_BUILTIN_FIRST_FPCMPSHL", "&&", "code", "<=", "SPARC_BUILTIN_LAST_FPCMPSHL", "&&", "arg_count", "==", "<NUM_LIT>", ")", "||", "(", "code", ">=", "SPARC_BUILTIN_FIRST_DICTUNPACK", "&&", "code", "<=", "SPARC_BUILTIN_LAST_DICTUNPACK", "&&", "arg_count", "==", "<NUM_LIT>", ")", ")", "{", "if", "(", "!", "check_constant_argument", "(", "icode", ",", "idx", ",", "op", "[", "arg_count", "]", ")", ")", "return", "const0_rtx", ";", "}", "if", "(", "code", "==", "SPARC_BUILTIN_LDFSR", "||", "code", "==", "SPARC_BUILTIN_STFSR", ")", "{", "if", "(", "!", "address_operand", "(", "op", "[", "arg_count", "]", ",", "SImode", ")", ")", "{" ]

[ "}" ]

[ "let", "OutOperandList", "=", "oops", ";", "let", "InOperandList", "=", "iops", ";", "let", "Pattern", "=", "pattern", ";", "let", "Predicates", "=", "preds", ";" ]

[ "let", "prefersSlot3", "=", "<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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{" ]

[ "void", "MipsSEDAGToDAGISel", "::", "initGlobalBaseReg", "(", "MachineFunction", "&", "MF", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MipsFI", "->", "globalBaseRegSet", "(", ")", ")", "return", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "V0", ",", "GlobalBaseReg", "=", "MipsFI", "->", "getGlobalBaseReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "RC", "=", "(", "Subtarget", "->", "isABI_N64", "(", ")", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "V0", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";" ]

[ ";" ]

[ "def", "L2_loadbsw4_pi", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "s4_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_71f1b4", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc" ]

[ "}" ]

[ "let", "InOperandList", "=", "(", "ins", "Src", ":", "$", "src", ",", "i32imm", ":", "$", "flavor", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "isAsmParserOnly", "=", "<NUM_LIT>", ";" ]

[ "CC_STATUS_INIT", ";" ]

[ "if", "(", "GET_CODE", "(", "exp", ")", "==", "SET", ")", "{", "if", "(", "SET_DEST", "(", "exp", ")", "==", "pc_rtx", ")", "return", ";", "if", "(", "REG_P", "(", "SET_DEST", "(", "exp", ")", ")", "&&", "(", "REG_P", "(", "SET_SRC", "(", "exp", ")", ")", "||", "GET_CODE", "(", "SET_SRC", "(", "exp", ")", ")", "==", "MEM", ")", ")", "{", "return", ";", "}", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "exp", ")", ")", "==", "MEM", "&&", "REG_P", "(", "SET_SRC", "(", "exp", ")", ")", ")", "{", "return", ";", "}", "}" ]

[ "}" ]

[ "if", "(", "InOpcode", "==", "ISD", "::", "EXTRACT_SUBVECTOR", "&&", "In", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "In", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "getOpcode_EXTEND", "(", "Opcode", ")", "&&", "In", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueSizeInBits", "(", ")", "==", "In", ".", "getValueSizeInBits", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "VT", ",", "In", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "DCI", ".", "isBeforeLegalizeOps", "(", ")", "&&", "Opcode", "==", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", "&&", "In", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", "&&", "In", ".", "hasOneUse", "(", ")", "&&", "In", ".", "getValueSizeInBits", "(", ")", "==", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "Scale", "=", "VT", ".", "getScalarSizeInBits", "(", ")", "/", "In", ".", "getScalarValueSizeInBits", "(", ")", ";", "EVT", "EltVT", "=", "In", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "SmallVector", "<", "SDValue", ">", "Elts", "(", "Scale", "*", "NumElts", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "EltVT", ")", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "!=", "NumElts", ";", "++", "I", ")", "Elts", "[", "I", "*", "Scale", "]", "=", "In", ".", "getOperand", "(", "I", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "DAG", ".", "getBuildVector", "(", "In", ".", "getValueType", "(", ")", ",", "DL", ",", "Elts", ")", ")", ";" ]

[ ";" ]

[ "if", "(", "X86", "::", "GR16RegClass", ".", "contains", "(", "Reg", ")", ")", "return", "&", "X86", "::", "GR16RegClass", ";", "if", "(", "X86", "::", "GR8RegClass", ".", "contains", "(", "Reg", ")", ")", "return", "&", "X86", "::", "GR8RegClass", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unknown RegClass for PhysReg!", "<STR_LIT>", ")" ]

[ "}" ]

[ "static", "inline", "bool", "s390_vector_bool_type_p", "(", "const_tree", "type", ")", "{", "return", "TYPE_VECTOR_OPAQUE", "(", "type", ")", ";" ]

[ "next", ";" ]

[ "tree", "fn", "=", "(", "tree", ")", "decl", ";", "struct", "cgraph_node", "*", "node", "=", "NULL", ";", "struct", "cgraph_node", "*", "default_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "node_v", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "first_v", "=", "NULL", ";", "tree", "dispatch_decl", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "default_version_info", "=", "NULL", ";", "gcc_assert", "(", "fn", "!=", "NULL", "&&", "DECL_FUNCTION_VERSIONED", "(", "fn", ")", ")", ";", "node", "=", "cgraph_node", "::", "get", "(", "fn", ")", ";", "gcc_assert", "(", "node", "!=", "NULL", ")", ";", "node_v", "=", "node", "->", "function_version", "(", ")", ";", "gcc_assert", "(", "node_v", "!=", "NULL", ")", ";", "if", "(", "node_v", "->", "dispatcher_resolver", "!=", "NULL", ")", "return", "node_v", "->", "dispatcher_resolver", ";", "first_v", "=", "node_v", ";", "while", "(", "first_v", "->", "prev", "!=", "NULL", ")", "first_v", "=", "first_v", "->", "prev", ";", "default_version_info", "=", "first_v", ";", "while", "(", "default_version_info", "!=", "NULL", ")", "{", "if", "(", "is_function_default_version", "(", "default_version_info", "->", "this_node", "->", "decl", ")", ")", "break", ";", "default_version_info", "=", "default_version_info", "->", "next", ";", "}", "if", "(", "default_version_info", "==", "NULL", ")", "return", "NULL", ";", "if", "(", "first_v", "!=", "default_version_info", ")", "{", "default_version_info", "->", "prev", "->", "next", "=", "default_version_info", "->" ]

[ "->", "getConstantFPValue", "(", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Values", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "SDValue", "V", "=", "Values", "[", "i", "]", ";", "if", "(", "V", ".", "isUndef", "(", ")", ")", "{", "Consts", "[", "i", "]", "=", "ConstantInt", "::", "get", "(", "IntTy", ",", "<NUM_LIT>", ")", ";", "continue", ";", "}", "if", "(", "auto", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V", ".", "getNode", "(", ")", ")", ")", "{", "const", "ConstantInt", "*", "CI", "=", "CN", "->", "getConstantIntValue", "(", ")", ";", "Consts", "[", "i", "]", "=", "ConstantInt", "::", "get", "(", "IntTy", ",", "CI", "->", "getValue", "(", ")", ".", "getSExtValue", "(", ")", ")", ";", "}", "else", "if", "(", "auto", "*", "CN", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "V", ".", "getNode", "(", ")", ")", ")", "{", "const", "ConstantFP", "*", "CF", "=", "CN" ]

[ "<FIXS>", "pa_output_indirect_call", "(", "rtx", "insn", ",", "rtx", "call_dest", ")", "<FIXE>" ]

[ "}", "const", "char", "*", "<BUGS>", "output_indirect_call", "(", "rtx", "insn", ",", "rtx", "call_dest", ")", "<BUGE>", "{", "rtx", "xoperands", "[", "<NUM_LIT>", "]", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V16QI", "[", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]" ]

[ ";" ]

[ "return", ";", "}", "if", "(", "Node", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FrameIndex", ")", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i16", ")", ";", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i16", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "Node", ")", ",", "MVT", "::", "i16", ")", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")" ]

[ ")", ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "match_code", "<STR_LIT>" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "unsigned", "ARMConstantIslands", "::", "getOffsetOf", "(", "MachineInstr", "*", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "unsigned", "Offset", "=", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ";", "&", "*", "I", "!=", "MI", ";", "++", "I", ")", "{", "assert", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "<STR_LIT>", "Didn't find MI in its own basic block?", "<STR_LIT>", ")", ";", "Offset", "+=", "TII", "->", "GetInstSizeInBytes", "(", "*", "I", ")", ";", "}", "return", "Offset", ";", "}" ]

[ "getOffsetOf", "-", "Return", "the", "current", "offset", "of", "the", "specified", "machine", "instruction", "from", "the", "start", "of", "the", "function", "." ]

[ "unsigned", "int", "get_builtin_code_for_version", "(", "tree", "decl", ",", "tree", "*", "predicate_list", ")", "{", "tree", "attrs", ";", "struct", "cl_target_option", "cur_target", ";", "tree", "target_node", ";", "struct", "cl_target_option", "*", "new", "_", "target", ";", "const", "char", "*", "arg_str", "=", "NULL", ";", "const", "char", "*", "attrs_str", "=", "NULL", ";", "char", "*", "tok_str", "=", "NULL", ";", "char", "*", "token", ";", "enum", "feature_priority", "priority", "=", "P_NONE", ";", "static", "unsigned", "int", "NUM_FEATURES", "=", "ARRAY_SIZE", "(", "isa_names_table", ")", ";", "unsigned", "int", "i", ";", "tree", "predicate_chain", "=", "NULL_TREE", ";", "tree", "predicate_decl", ",", "predicate_arg", ";", "attrs", "=", "lookup_attribute", "(", "<STR_LIT>", "target", "<STR_LIT>", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "gcc_assert", "(", "attrs", "!=", "NULL", ")", ";", "attrs", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "attrs", ")", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "attrs", ")", "==", "STRING_CST", ")", ";", "attrs_str", "=", "TREE_STRING_POINTER", "(", "attrs", ")", ";", "if", "(", "strcmp", "(", "attrs_str", ",", "<STR_LIT>", "default", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "strstr", "(", "attrs_str", ",", "<STR_LIT>", "arch=", "<STR_LIT>", ")", "!=", "NULL", ")", "{", "cl_target_option_save", "(", "&", "cur_target", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "target_node", "=", "ix86_valid_target_attribute_tree", "(", "decl", ",", "attrs", ",", "&", "global_options", ",", "&", "global_options_set", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "target_node", ")", ";", "if", "(", "target_node", "==", "error_mark_node", ")", "return", "<NUM_LIT>", ";", "new", "_", "target", "=", "TREE_TARGET_OPTION", "(", "target_node", ")", ";", "gcc_assert", "(", "new", "_", "target", ")", ";", "enum", "ix86_builtins", "builtin_fn", "=", "IX86_BUILTIN_CPU_IS", ";", "const", "char", "*", "arch_name", "=", "attrs_str", "+", "strlen", "(", "<STR_LIT>", "arch=", "<STR_LIT>", ")", ";", "if", "(", "startswith", "(", "arch_name", ",", "<STR_LIT>", "x86-64", "<STR_LIT>", ")", ")", "{", "arg_str", "=", "arch_name", ";", "builtin_fn", "=", "IX86_BUILTIN_CPU_SUPPORTS", ";", "if", "(", "strcmp", "(", "arch_name", ",", "<STR_LIT>", "x86-64", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "priority", "=", "P_X86_64_BASELINE", ";", "else", "if", "(", "strcmp", "(", "arch_name", ",", "<STR_LIT>", "x86-64-v2", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "priority", "=", "P_X86_64_V2", ";", "else", "if", "(", "strcmp", "(", "arch_name", ",", "<STR_LIT>", "x86-64-v3", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "priority", "=", "P_X86_64_V3", ";", "else", "if", "(", "strcmp", "(", "arch_name", ",", "<STR_LIT>", "x86-64-v4", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "priority", "=", "P_X86_64_V4", ";", "}", "else", "if", "(", "new", "_", "target", "->", "arch_specified", "&&", "new", "_", "target", "->", "arch", ">", "<NUM_LIT>", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "pta_size", ";", "i", "++", ")", "if", "(", "processor_alias_table", "[", "i", "]", ".", "processor", "==", "new", "_", "target", "->", "arch", ")", "{", "const", "pta", "*", "arch_info", "=", "&", "processor_alias_table", "[", "i", "]", ";", "switch", "(", "arch_info", "->", "priority", ")", "{", "default", ":", "arg_str", "=", "arch_info", "->", "name", ";", "priority", "=", "arch_info", "->", "priority", ";", "break", ";", "case", "P_PROC_DYNAMIC", ":", "switch", "(", "new", "_", "target", "->", "arch", ")", "{", "case", "PROCESSOR_NEHALEM", ":", "if", "(", "TARGET_PCLMUL_P", "(", "new", "_", "target", "->", "x_ix86_isa_flags", ")", ")", "{", "arg_str", "=", "<STR_LIT>", "westmere", "<STR_LIT>", ";", "priority", "=", "P_PCLMUL", ";", "}", "else", "{", "arg_str", "=", "<STR_LIT>", "corei7", "<STR_LIT>", ";", "priority", "=", "P_PROC_SSE4_2", ";", "}", "break", ";", "case", "PROCESSOR_SANDYBRIDGE", ":", "if", "(", "TARGET_F16C_P", "(", "new", "_", "target", "->", "x_ix86_isa_flags", ")", ")", "arg_str", "=", "<STR_LIT>", "ivybridge", "<STR_LIT>", ";", "else", "arg_str", "=", "<STR_LIT>", "sandybridge", "<STR_LIT>", ";", "priority", "=", "P_PROC_AVX", ";", "break", ";", "case", "PROCESSOR_HASWELL", ":", "if", "(", "TARGET_ADX_P", "(", "new", "_", "target", "->", "x_ix86_isa_flags", ")", ")", "arg_str", "=", "<STR_LIT>", "broadwell", "<STR_LIT>", ";", "else", "arg_str", "=", "<STR_LIT>", "haswell", "<STR_LIT>", ";", "priority", "=", "P_PROC_AVX2", ";", "break", ";", "case", "PROCESSOR_AMDFAM10", ":", "arg_str", "=", "<STR_LIT>", "amdfam10h", "<STR_LIT>", ";", "priority", "=", "P_PROC_SSE4_A", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "P_NONE", ":", "break", ";", "}", "break", ";", "}", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "&", "cur_target", ")", ";", "if", "(", "predicate_list", "&&", "arg_str", "==", "NULL", ")", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "<STR_LIT>", "no dispatcher found for the versioning attributes", "<STR_LIT>", ")", ";", "return", "<NUM_LIT>", ";", "}", "if", "(", "predicate_list", ")", "{", "predicate_decl", "=", "ix86_builtins", "[", "(", "int", ")", "builtin_fn", "]", ";", "predicate_arg", "=", "build_string_literal", "(", "strlen", "(", "arg_str", ")", "+", "<NUM_LIT>", ",", "arg_str", ")", ";", "predicate_chain", "=", "tree_cons", "(", "predicate_decl", ",", "predicate_arg", ",", "predicate_chain", ")", ";", "}", "}", "tok_str", "=", "(", "char", "*", ")", "xmalloc", "(", "strlen", "(", "attrs_str", ")", "+", "<NUM_LIT>", ")", ";", "strcpy", "(", "tok_str", ",", "attrs_str", ")", ";", "token", "=", "strtok", "(", "tok_str", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "predicate_decl", "=", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_CPU_SUPPORTS", "]", ";", "while", "(", "token", "!=", "NULL", ")", "{", "if", "(", "startswith", "(", "token", ",", "<STR_LIT>", "arch=", "<STR_LIT>", ")", ")", "{", "token", "=", "strtok", "(", "NULL", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "continue", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "NUM_FEATURES", ";", "++", "i", ")", "{", "if", "(", "strcmp", "(", "token", ",", "isa_names_table", "[", "i", "]", ".", "name", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "predicate_list", ")", "{", "predicate_arg", "=", "build_string_literal", "(", "strlen", "(", "isa_names_table", "[", "i", "]", ".", "name", ")", "+", "<NUM_LIT>", ",", "isa_names_table", "[", "i", "]", ".", "name", ")", ";", "predicate_chain", "=", "tree_cons", "(", "predicate_decl", ",", "predicate_arg", ",", "predicate_chain", ")", ";", "}", "if", "(", "isa_names_table", "[", "i", "]", ".", "priority", ">", "priority", ")", "priority", "=", "isa_names_table", "[", "i", "]", ".", "priority", ";", "break", ";", "}", "}", "if", "(", "predicate_list", "&&", "priority", "==", "P_NONE", ")", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "<STR_LIT>", "ISA %qs is not supported in %<target%> attribute, ", "<STR_LIT>", "<STR_LIT>", "use %<arch=%> syntax", "<STR_LIT>", ",", "token", ")", ";", "return", "<NUM_LIT>", ";", "}", "token", "=", "strtok", "(", "NULL", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "}", "free", "(", "tok_str", ")", ";", "if", "(", "predicate_list", "&&", "predicate_chain", "==", "NULL_TREE", ")", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "<STR_LIT>", "no dispatcher found for the versioning attributes: %s", "<STR_LIT>", ",", "attrs_str", ")", ";", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "predicate_list", ")", "{", "predicate_chain", "=", "nreverse", "(", "predicate_chain", ")", ";", "*", "predicate_list", "=", "predicate_chain", ";", "}", "return", "priority", ";", "}" ]

[ "This", "parses", "the", "attribute", "arguments", "to", "target", "in", "DECL", "and", "determines", "the", "right", "builtin", "to", "use", "to", "match", "the", "platform", "specification", ".", "It", "returns", "the", "priority", "value", "for", "this", "version", "decl", ".", "If", "PREDICATE_LIST", "is", "not", "NULL", ",", "it", "stores", "the", "list", "of", "cpu", "features", "that", "need", "to", "be", "checked", "before", "dispatching", "this", "function", "." ]

[ "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "DA", "=", "&", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "(", "*", "I", ")", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "*", "I", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "*", "I", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "assert", "(", "Stack", ".", "empty", "(", ")", ")", ";", "return", "true", ";", "}" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "}" ]

[ "def", "v2i32_shift", ":", "BaseSIMDVectorShiftTied", "<", "<NUM_LIT>", ",", "U", ",", "opc", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", "}", ",", "V64", ",", "V64", ",", "vecshiftR32", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v2i32", "V64", ":", "$", "dst", ")", ",", "(", "OpNode", "(", "v2i32", "V64", ":", "$", "Rd", ")", ",", "(", "v2i32", "V64", ":", "$", "Rn", ")", ",", "(", "i32", "vecshiftR32", ":", "$", "imm", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";" ]

[ "Reg", ")", "{" ]

[ "void", "HexagonExpandCondsets", "::", "recalculateLiveInterval", "(", "Register" ]

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

[ "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "<NUM_LIT>", ";", "break", ";", "default", ":", "break", ";", "}" ]

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

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

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

[ "static", "bool", "memOpsHaveSameBasePtr", "(", "const", "MachineInstr", "&", "MI1", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps1", ",", "const", "MachineInstr", "&", "MI2", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps2", ")", "{", "if", "(", "BaseOps1", ".", "front", "(", ")", "->", "isIdenticalTo", "(", "*", "BaseOps2", ".", "front", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "MI1", ".", "hasOneMemOperand", "(", ")", "||", "!", "MI2", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "auto", "MO1", "=", "*", "MI1", ".", "memoperands_begin", "(", ")", ";", "auto", "MO2", "=", "*", "MI2", ".", "memoperands_begin", "(", ")", ";", "if", "(", "MO1", "->", "getAddrSpace", "(", ")", "!=", "MO2", "->", "getAddrSpace", "(", ")", ")", "return", "false", ";", "auto", "Base1", "=", "MO1", "->" ]

[ "<FIXS>", "gcc_unreachable", "(", ")", ";", "<FIXE>" ]

[ "type", "=", "int_ftype_int_v2sf_v2sf", ";", "break", ";", "default", ":", "<BUGS>", "abort", "(", ")", ";", "<BUGE>", "}", "def_builtin", "(", "d", "->", "mask", ",", "d", "->", "name", ",", "type", ",", "d", "->", "code", ")", ";" ]

[ "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_cvtps_epi32", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_cvtps2dq128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "mm_avx512_setzero_si128", "(", ")", "," ]

[ "<STR_LIT>", ";" ]

[ "return", "<STR_LIT>", "ARM64 branch relaxation pass" ]

[ "}" ]

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";" ]

[ "Value", "*", "NewVal", "=", "insertValues", "(", "Builder", ",", "Ty", ",", "ResultVals", ")", ";" ]

[ "}", "else", "if", "(", "ST", "->", "hasMulI24", "(", ")", "&&", "isI24", "(", "LHS", ",", "Size", ")", "&&", "isI24", "(", "RHS", ",", "Size", ")", ")", "{", "IntrID", "=", "Intrinsic", "::", "amdgcn_mul_i24", ";", "}", "else", "return", "false", ";", "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "LHSVals", ";", "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "RHSVals", ";", "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "ResultVals", ";", "extractValues", "(", "Builder", ",", "LHSVals", ",", "LHS", ")", ";", "extractValues", "(", "Builder", ",", "RHSVals", ",", "RHS", ")", ";", "IntegerType", "*", "I32Ty", "=", "Builder", ".", "getInt32Ty", "(", ")", ";", "FunctionCallee", "Intrin", "=", "Intrinsic", "::", "getDeclaration", "(", "Mod", ",", "IntrID", ")", ";", "for", "(", "int", "I", "=", "<NUM_LIT>", ",", "E", "=", "LHSVals", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Value", "*", "LHS", ",", "*", "RHS", ";", "if", "(", "IntrID", "==", "Intrinsic", "::", "amdgcn_mul_u24", ")", "{", "LHS", "=", "Builder", ".", "CreateZExtOrTrunc", "(", "LHSVals", "[", "I", "]", ",", "I32Ty", ")", ";", "RHS", "=", "Builder", ".", "CreateZExtOrTrunc", "(", "RHSVals", "[", "I", "]", ",", "I32Ty", ")", ";", "}", "else", "{", "LHS", "=", "Builder", ".", "CreateSExtOrTrunc", "(", "LHSVals", "[", "I", "]", ",", "I32Ty", ")", ";", "RHS", "=", "Builder", ".", "CreateSExtOrTrunc", "(", "RHSVals", "[", "I", "]", ",", "I32Ty", ")", ";", "}", "Value", "*", "Result", "=", "Builder", ".", "CreateCall", "(", "Intrin", ",", "{", "LHS", ",", "RHS", "}", ")", ";", "if", "(", "IntrID", "==", "Intrinsic", "::", "amdgcn_mul_u24", ")", "{", "ResultVals", ".", "push_back", "(", "Builder", ".", "CreateZExtOrTrunc", "(", "Result", ",", "LHSVals", "[", "I", "]", "->", "getType", "(", ")", ")", ")", ";", "}", "else", "{", "ResultVals", ".", "push_back", "(", "Builder", ".", "CreateSExtOrTrunc", "(", "Result", ",", "LHSVals", "[", "I", "]", "->", "getType", "(", ")", ")", ")", ";", "}", "}" ]

[ "extract_val", "=", "INTVAL", "(", "extract_imm", ")", ";" ]

[ "HOST_WIDE_INT", "mult_val", ",", "extract_val", ";", "if", "(", "!", "CONST_INT_P", "(", "mult_imm", ")", "||", "!", "CONST_INT_P", "(", "extract_imm", ")", ")", "return", "false", ";", "mult_val", "=", "INTVAL", "(", "mult_imm", ")", ";" ]

[ "<FIXS>", "if", "(", "Encoding", "==", "<NUM_LIT>", ")", "Rex", "=", "emitOpcodePrefix", "(", "CurByte", ",", "MemoryOperand", ",", "MI", ",", "STI", ",", "OS", ")", ";", "<FIXE>", "<FIXS>", "emitVEXOpcodePrefix", "(", "CurByte", ",", "MemoryOperand", ",", "MI", ",", "OS", ")", ";", "<FIXE>" ]

[ "uint64_t", "Encoding", "=", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGS>", "bool", "HasREX", "=", "false", ";", "if", "(", "Encoding", ")", "emitVEXOpcodePrefix", "(", "CurByte", ",", "MemoryOperand", ",", "MI", ",", "OS", ")", ";", "<BUGE>", "else", "<BUGS>", "HasREX", "=", "emitOpcodePrefix", "(", "CurByte", ",", "MemoryOperand", ",", "MI", ",", "STI", ",", "OS", ")", ";", "<BUGE>", "uint64_t", "Form", "=", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "switch", "(", "Form", ")", "{" ]

[ "}" ]

[ "MF", "=", "&", "MFParam", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "AllCRLogicalOps", ".", "clear", "(", ")", ";" ]

[ "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_rorv_epi32", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_prorvd128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "_", "B", ",", "(", "_", "_", "v4si", ")", "_", "mm_setzero_si128", "(", ")", ",", "(", "_", "_" ]

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

[ "(", "float_extend", ":", "V2DF", "(", "vec_select", ":", "V2SF", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "class", "Enc_28dcbb", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Rt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Mu2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Mu2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vvv32" ]

[ "addPass", "(", "createSIWholeQuadModePass", "(", ")", ")", ";" ]

[ "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";" ]

[ ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "N1", ")", ";" ]

[ "if", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "&&", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "N1", "&&", "isZero", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N1", ")", ";", "if", "(", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "&&", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "N0", "&&", "isZero", "(", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N0", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "N1", "&&", "isAllOnes", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N1", ")", ";", "if", "(", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "N0", "&&", "isAllOnes", "(", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N0", ")", ";", "return", "SDValue", "(", ")", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "v2i64", "&&", "VT", "!=", "MVT", "::", "v4i64", ")", "return", "SDValue", "(", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "DL", "=", "N", "->", "getDebugLoc", "(", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", "&&", "CanFoldXORWithAllOnes", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ")", "return", "DAG" ]

[ "}" ]

[ "def", "_fixed", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", "VecListOneDAllLanes", ":", "$", "Vd", ",", "GPR", ":", "$", "wb", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ")", ",", "IIC_VLD1dupu", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

[ "def", "A2_vsubws", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "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", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "Instruction", "inst", ">", "{", "<FIXE>" ]

[ "let", "Predicates", "=", "[", "Has16BitInsts", ",", "isGFX6GFX7GFX8GFX9", "]", "in", "{", "multiclass", "Ternary_i16_Pats", "SDPatternOperator", "op1", ",", "SDPatternOperator", "op2", ",", "<BUGS>", "Instruction", "inst", ",", "SDPatternOperator", "op3", ">", "{", "<BUGE>", "def", ":", "GCNPat", "(", "op2", "(", "op1", "i16", ":", "$", "src0", ",", "i16", ":", "$", "src1", ")", ",", "i16", ":", "$", "src2", ")", ",", "(", "inst", "i16", ":", "$", "src0", ",", "i16", ":", "$", "src1", ",", "i16", ":", "$", "src2", ",", "(", "i1", "<NUM_LIT>", ")", ")" ]

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

[ "def", "A64FXWrite_LD113", ":", "SchedWriteRes", "<", "[", "A64FXGI56", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "getType", "(", "ValVReg", ")", ";" ]

[ "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "Register", "Addr", ",", "uint64_t", "MemSize", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "Register", "ValVReg", "=", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", "?", "extendRegister", "(", "Arg", ".", "Regs", "[", "<NUM_LIT>", "]", ",", "VA", ")", ":", "Arg", ".", "Regs", "[", "<NUM_LIT>", "]", ";", "const", "LLT", "RegTy", "=", "MRI", "." ]

[ "}" ]

[ "let", "addrMode", "=", "Absolute", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "InstructionCost", "SystemZTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "BitSize", ">", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", "==", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "<NUM_LIT>", ")", "{", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "<NUM_LIT>", "*", "TTI", "::", "TCC_Basic", ";", "}", "return", "<NUM_LIT>", "*", "TTI", "::", "TCC_Basic", ";", "}" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "{" ]

[ "bool", "hasSMAP", "(", ")", "const" ]

[ "<FIXS>", "def", ":", "Pat", "(", "store", "(", "i32", "(", "extractelt", "v4i32", ":", "$", "A", ",", "<NUM_LIT>", ")", ")", ",", "ForceXForm", ":", "$", "src", ")", ",", "(", "STIWX", "(", "EXTRACT_SUBREG", "$", "A", ",", "sub_64", ")", ",", "ForceXForm", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "store", "(", "f32", "(", "extractelt", "v4f32", ":", "$", "A", ",", "<NUM_LIT>", ")", ")", ",", "ForceXForm", ":", "$", "src", ")", ",", "(", "STIWX", "(", "EXTRACT_SUBREG", "$", "A", ",", "sub_64", ")", ",", "ForceXForm", ":", "$", "src", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "Pat", "(", "store", "(", "i32", "(", "extractelt", "v4i32", ":", "$", "A", ",", "!", "head", "(", "Idx", ")", ")", ")", ",", "ForceXForm", ":", "$", "src", ")", ",", "<FIXE>", "<FIXS>", "sub_64", ")", ",", "ForceXForm", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "store", "(", "f32", "(", "extractelt", "v4f32", ":", "$", "A", ",", "!", "head", "(", "Idx", ")", ")", ")", ",", "ForceXForm", ":", "$", "src", ")", ",", "<FIXE>", "<FIXS>", "sub_64", ")", ",", "ForceXForm", ":", "$", "src", ")", ">", ";", "<FIXE>" ]

[ "def", ":", "Pat", "DWToSPExtractConv", ".", "BVS", ",", "(", "v4f32", "(", "VPKUDUM", "(", "XXSLDWI", "(", "XVCVSXDSP", "$", "S1", ")", ",", "(", "XVCVSXDSP", "$", "S1", ")", ",", "<NUM_LIT>", ")", ",", "(", "XXSLDWI", "(", "XVCVSXDSP", "$", "S2", ")", ",", "(", "XVCVSXDSP", "$", "S2", ")", ",", "<NUM_LIT>", ")", ")", ")", ">", ";", "<BUGS>", "def", ":", "Pat", "(", "store", "(", "i32", "(", "extractelt", "v4i32", ":", "$", "A", ",", "<NUM_LIT>", ")", ")", ",", "xoaddr", ":", "$", "src", ")", ",", "(", "STIWX", "(", "EXTRACT_SUBREG", "$", "A", ",", "sub_64", ")", ",", "xoaddr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "store", "(", "f32", "(", "extractelt", "v4f32", ":", "$", "A", ",", "<NUM_LIT>", ")", ")", ",", "xoaddr", ":", "$", "src", ")", ",", "(", "STIWX", "(", "EXTRACT_SUBREG", "$", "A", ",", "sub_64", ")", ",", "xoaddr", ":", "$", "src", ")", ">", ";", "<BUGE>", "foreach", "Idx", "=", "[", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", "]", "in", "{", "<BUGS>", "def", ":", "Pat", "(", "store", "(", "i32", "(", "extractelt", "v4i32", ":", "$", "A", ",", "!", "head", "(", "Idx", ")", ")", ")", ",", "xoaddr", ":", "$", "src", ")", ",", "<BUGE>", "(", "STIWX", "(", "EXTRACT_SUBREG", "(", "XXSLDWI", "$", "A", ",", "$", "A", ",", "!", "head", "(", "!", "tail", "(", "Idx", ")", ")", ")", ",", "<BUGS>", "sub_64", ")", ",", "xoaddr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "store", "(", "f32", "(", "extractelt", "v4f32", ":", "$", "A", ",", "!", "head", "(", "Idx", ")", ")", ")", ",", "xoaddr", ":", "$", "src", ")", ",", "<BUGE>", "(", "STIWX", "(", "EXTRACT_SUBREG", "(", "XXSLDWI", "$", "A", ",", "$", "A", ",", "!", "head", "(", "!", "tail", "(", "Idx", ")", ")", ")", ",", "<BUGS>", "sub_64", ")", ",", "xoaddr", ":", "$", "src", ")", ">", ";", "<BUGE>", "}", "}" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ "static", "rtx", "frv_io_address_cookie", "(", "rtx", "address", ")", "{", "return", "(", "GET_CODE", "(", "address", ")", "==", "CONST_INT", "?", "GEN_INT", "(", "INTVAL", "(", "address", ")", "/", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ":", "const0_rtx", ")", ";", "}" ]

[ "Given", "that", "a", "__builtin_read", "or", "__builtin_write", "function", "is", "accessing", "address", "ADDRESS", ",", "return", "the", "value", "that", "should", "be", "used", "as", "operand", "1", "of", "the", "membar", "." ]

[ "bool", "R600InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "isBranch", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "isJump", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "return", "false", ";", "}", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "I", ")", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "PriorI", "=", "std", "::", "prev", "(", "I", ")", ";", "if", "(", "AllowModify", ")", "I", "->", "removeFromParent", "(", ")", ";", "I", "=", "PriorI", ";", "}", "MachineInstr", "&", "LastInst", "=", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isJump", "(", "(", "--", "I", ")", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "LastOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "TBB", "=", "LastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "if", "(", "LastOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "auto", "predSet", "=", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "LastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "&", "SecondLastInst", "=", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "SecondLastOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "LastOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "auto", "predSet", "=", "--", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "FBB", "=", "LastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "*", "this", ")", ";" ]

[ "return", "new", "SPULinuxTargetAsmInfo", "(" ]

[ "void", "WebAssemblyMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint64_t", "Start", "=", "OS", ".", "tell", "(", ")", ";", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "if", "(", "Binary", "<=", "UINT8_MAX", ")", "{", "OS", "<<", "uint8_t", "(", "Binary", ")", ";", "}", "else", "{", "assert", "(", "Binary", "<=", "UINT16_MAX", "&&", "<STR_LIT>", "Several-byte opcodes not supported yet", "<STR_LIT>", ")", ";", "OS", "<<", "uint8_t", "(", "Binary", ">>", "<NUM_LIT>", ")", ";", "encodeULEB128", "(", "uint8_t", "(", "Binary", ")", ",", "OS", ")", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I32_S", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I64_S", ")", "encodeULEB128", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ",", "OS", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I32", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I64", ")", "encodeULEB128", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ",", "OS", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "if", "(", "I", "<", "Desc", ".", "getNumOperands", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Encoding immediate: type=", "<STR_LIT>", "<<", "int", "(", "Info", ".", "OperandType", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "switch", "(", "Info", ".", "OperandType", ")", "{", "case", "WebAssembly", "::", "OPERAND_I32IMM", ":", "encodeSLEB128", "(", "int32_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_OFFSET32", ":", "encodeULEB128", "(", "uint32_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_I64IMM", ":", "encodeSLEB128", "(", "int64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_SIGNATURE", ":", "OS", "<<", "uint8_t", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I8IMM", ":", "support", "::", "endian", "::", "write", "<", "uint8_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I16IMM", ":", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I32IMM", ":", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I64IMM", ":", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_GLOBAL", ":", "llvm_unreachable", "(", "<STR_LIT>", "wasm globals should only be accessed symbolicly", "<STR_LIT>", ")", ";", "default", ":", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "{", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F32IMM", ")", "{", "auto", "F", "=", "float", "(", "MO", ".", "getFPImm", "(", ")", ")", ";", "support", "::", "endian", "::", "write", "<", "float", ">", "(", "OS", ",", "F", ",", "support", "::", "little", ")", ";", "}", "else", "{", "assert", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F64IMM", ")", ";", "double", "D", "=", "MO", ".", "getFPImm", "(", ")", ";", "support", "::", "endian", "::", "write", "<", "double", ">", "(", "OS", ",", "D", ",", "support", "::", "little", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "llvm", "::", "MCFixupKind", "FixupKind", ";", "size_t", "PaddedSize", "=", "<NUM_LIT>", ";", "switch", "(", "Info", ".", "OperandType", ")", "{", "case", "WebAssembly", "::", "OPERAND_I32IMM", ":", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_sleb128_i32", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_I64IMM", ":", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_sleb128_i64", ")", ";", "PaddedSize", "=", "<NUM_LIT>", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_FUNCTION32", ":", "case", "WebAssembly", "::", "OPERAND_OFFSET32", ":", "case", "WebAssembly", "::", "OPERAND_SIGNATURE", ":", "case", "WebAssembly", "::", "OPERAND_TYPEINDEX", ":", "case", "WebAssembly", "::", "OPERAND_GLOBAL", ":", "case", "WebAssembly", "::", "OPERAND_EVENT", ":", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_uleb128_i32", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unexpected symbolic operand kind", "<STR_LIT>", ")", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "OS", ".", "tell", "(", ")", "-", "Start", ",", "MO", ".", "getExpr", "(", ")", ",", "FixupKind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "encodeULEB128", "(", "<NUM_LIT>", ",", "OS", ",", "PaddedSize", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "unexpected operand kind", "<STR_LIT>", ")", ";", "}", "}", "++", "MCNumEmitted", ";", "}" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "<FIXS>", "EVEX_RC", "=", "<NUM_LIT>", "ULL", "<<", "EVEX_RCShift", ",", "NoTrackShift", "=", "EVEX_RCShift", "+", "<NUM_LIT>", ",", "NOTRACK", "=", "<NUM_LIT>", "ULL", "<<", "NoTrackShift", "<FIXE>" ]

[ "EVEX_RCShift", "=", "Has3DNow0F0FOpcodeShift", "+", "<NUM_LIT>", ",", "<BUGS>", "EVEX_RC", "=", "<NUM_LIT>", "ULL", "<<", "EVEX_RCShift", "<BUGE>", "}", ";" ]

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

[ "int", "HexagonTTIImpl", "::", "getUserCost", "(", "const", "User", "*", "U", ")", "{", "auto", "isCastFoldedIntoLoad", "=", "[", "]", "(", "const", "CastInst", "*", "CI", ")", "->", "bool", "{", "if", "(", "!", "CI", "->", "isIntegerCast", "(", ")", ")", "return", "false", ";", "const", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "const", "LoadInst", ">", "(", "CI", "->", "getOperand", "(" ]

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

[ "(", "unspec", ":", "V4SF", "[", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VEXPTEFP", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "const", "X86FrameLowering", "*", "getFrameLowering", "(", ")", "const", "{", "return", "&", "FrameLowering", ";" ]

[ "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ ",", "op1", ",", "op2", ")", ")" ]

[ "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "op1", "=", "gen_reg_rtx", "(", "V4HImode", ")", "rtx", "op2", "=", "gen_reg_rtx", "(", "V4HImode", ")", "emit_insn", "(", "gen_vec_unpacks_hi_v8qi", "(", "op1", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_vec_unpacks_hi_v8qi", "(", "op2", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_mulv4hi3", "(", "operands", "[", "<NUM_LIT>", "]" ]

[ "}" ]

[ "vmulq_n_u32", "(", "uint32x4_t", "_", "_", "a", ",", "uint32_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "*", "_", "_", "b", ";" ]

[ "(", "uint32_t", "insn", ")", "{" ]

[ "static", "inline", "unsigned", "GetCopOpc2" ]

[ "}" ]

[ "const", "SDValue", "&", "getMask", "(", ")", "const", "{", "return", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_cmple_epu32_mask", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m256i", "_", "_", "X", ",", "_", "_", "m256i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_ucmpd256_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "X", ",", "(", "_", "_", "v8si", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask8", ")", "_", "_", "M", ")", ";" ]

[ "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";" ]

[ "if", "(", "EmitFPOData", ")", "{", "auto", "*", "XTS", "=", "static_cast", "<", "X86TargetStreamer", "*", ">" ]

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

[ "(", "define_mode_iterator", "VDQQH", "[", "V8QI", "V16QI", "V4HI" ]

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

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

[ "}" ]

[ "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "{" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "SP_REGNUM", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

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

[ "(", "define_automaton", "<STR_LIT>", ")", "(", "define_cpu_unit" ]

[ "}" ]

[ "class", "VLD1QLNPseudo", "<", "ValueType", "Ty", ",", "PatFrag", "LoadOp", ">", ":", "VLDQLNPseudo", "<", "IIC_VLD1ln", ">", ",", "Sched", "<", "[", "WriteVLD1", "]", ">", "{", "let", "Pattern", "=", "[", "(", "set", "QPR", ":", "$", "dst", ",", "(", "vector_insert", "(", "Ty", "QPR", ":", "$", "src", ")", ",", "(", "i32", "(", "LoadOp", "addrmode6", ":", "$", "addr", ")", ")", ",", "imm", ":", "$", "lane", ")", ")", "]", ";" ]

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

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

[ "}" ]

[ "ia64_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "if", "(", "next_cum", ".", "words", "<", "MAX_ARGUMENT_SLOTS", ")", "{", "int", "n", "=", "MAX_ARGUMENT_SLOTS", "-", "next_cum", ".", "words", ";", "*", "pretend_size", "=", "n", "*", "UNITS_PER_WORD", ";", "cfun", "->", "machine", "->", "n_varargs", "=", "n", ";", "}" ]

[ "_", "P", "=", "_", "_", "A", ";" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_store_epi64", "(", "void", "*", "_", "_", "P", ",", "_", "_", "m256i", "_", "_", "A", ")", "{", "*", "(", "_", "_", "m256i", "*", ")", "_" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_fmadd_round_sch", "(", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ",", "const", "int", "_", "_", "D", ")", "{", "return", "(", "_", "_", "m128h", ")", "_", "_", "builtin_ia32_vfmaddcsh_round", "(", "(", "_", "_", "v8hf", ")", "_", "_", "A", ",", "(", "_", "_", "v8hf", ")", "_", "_", "B", ",", "(", "_", "_", "v8hf", ")", "_", "_", "C", ",", "_", "_", "D", ")", ";" ]

[ "MachineInstr", "*", "SparcInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FI", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "NULL", ";", "unsigned", "OpNum", "=", "Ops", "[", "<NUM_LIT>", "]", ";", "bool", "isFloat", "=", "false", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "else", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "isFloat", "=", "true", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isUndef", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isUndef", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "break", ";", "}", "return", "NewMI", ";", "}" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rdd32", ";" ]

[ "<FIXS>", "!", "eq", "(", "VT", ",", "bf16", ")", ":", "!", "if", "(", "IsTrue16", ",", "VSrcT_bf16", ",", "VSrc_bf16", ")", ",", "<FIXE>", "<FIXS>", "!", "eq", "(", "VT", ",", "v2bf16", ")", ":", "VSrc_v2bf16", ",", "<FIXE>" ]

[ "!", "cond", "(", "!", "eq", "(", "VT", ",", "f64", ")", ":", "VSrc_f64", ",", "!", "eq", "(", "VT", ",", "f32", ")", ":", "VSrc_f32", ",", "!", "eq", "(", "VT", ",", "f16", ")", ":", "!", "if", "(", "IsTrue16", ",", "VSrcT_f16", ",", "VSrc_f16", ")", ",", "<BUGS>", "!", "eq", "(", "VT", ",", "bf16", ")", ":", "!", "if", "(", "IsTrue16", ",", "VSrcT_f16", ",", "VSrc_f16", ")", ",", "<BUGE>", "!", "eq", "(", "VT", ",", "i16", ")", ":", "!", "if", "(", "IsTrue16", ",", "VSrcT_b16", ",", "VSrc_b16", ")", ",", "!", "eq", "(", "VT", ",", "i1", ")", ":", "SSrc_i1", ",", "!", "eq", "(", "VT", ",", "v2f32", ")", ":", "VSrc_v2f32", ",", "!", "eq", "(", "VT", ",", "v2i32", ")", ":", "VSrc_v2b32", ",", "!", "eq", "(", "VT", ",", "v2f16", ")", ":", "VSrc_v2f16", ",", "<BUGS>", "!", "eq", "(", "VT", ",", "v2bf16", ")", ":", "VSrc_v2f16", ",", "<BUGE>", "!", "eq", "(", "VT", ",", "v2i16", ")", ":", "VSrc_v2b16", ",", "!", "eq", "(", "VT", ",", "v4f16", ")", ":", "AVSrc_64", ",", "!", "eq", "(", "VT", ",", "v4bf16", ")", ":", "AVSrc_64", "," ]

[ "MCRegister", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";" ]

[ "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_POPS_EXITING_WAVE_ID", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "XNACK_MASK", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "LDS_DIRECT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP12_TTMP13", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP14_TTMP15", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SGPR_NULL", ")", ";", "if", "(", "isWave32", ")", "{", "Reserved", ".", "set", "(", "AMDGPU", "::", "VCC", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "VCC_HI", ")", ";", "}", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "if", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "MaxNumVGPRs", "/", "=", "<NUM_LIT>", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "Reg", "=", "AMDGPU", "::", "AGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "for", "(", "auto", "Reg", ":", "AMDGPU", "::", "SReg_32RegClass", ")", "{", "Reserved", ".", "set", "(", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "hi16", ")", ")", ";", "Register", "Low", "=", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "lo16", ")", ";", "if", "(", "!", "AMDGPU", "::", "SGPR_LO16RegClass", ".", "contains", "(", "Low", ")", ")", "Reserved", ".", "set", "(", "Low", ")", ";", "}", "for", "(", "auto", "Reg", ":", "AMDGPU", "::", "AGPR_32RegClass", ")", "{", "Reserved", ".", "set", "(", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "hi16", ")", ")", ";", "}", "if", "(", "!", "ST", ".", "hasMAIInsts", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "MaxNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "AGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Register", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "}", "MCRegister", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}" ]

[ "<FIXS>", "StringRef", "toString", "(", "uint32_t", "Value", ",", "const", "FeatureBitset", "&", "FeatureBits", ",", "bool", "&", "Valid", ")", "const", ";", "uint32_t", "fromString", "(", "StringRef", "Name", ",", "const", "FeatureBitset", "&", "FeatureBits", ",", "bool", "&", "Valid", ")", "const", ";", "<FIXE>" ]

[ "AArch64NamedImmMapper", "(", "const", "Mapping", "(", "&", "Mappings", ")", "[", "N", "]", ",", "uint32_t", "TooBigImm", ")", ":", "Mappings", "(", "&", "Mappings", "[", "<NUM_LIT>", "]", ")", ",", "NumMappings", "(", "N", ")", ",", "TooBigImm", "(", "TooBigImm", ")", "{", "}", "<BUGS>", "StringRef", "toString", "(", "uint32_t", "Value", ",", "uint64_t", "FeatureBits", ",", "bool", "&", "Valid", ")", "const", ";", "uint32_t", "fromString", "(", "StringRef", "Name", ",", "uint64_t", "FeatureBits", ",", "bool", "&", "Valid", ")", "const", ";", "<BUGE>" ]

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

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

[ "void", "dump", "(", ")", "const", "{", "if", "(", "Start", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found Loop Start: ", "<STR_LIT>", "<<", "*", "Start", ";", "if", "(", "Dec", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found Loop Dec: ", "<STR_LIT>", "<<", "*", "Dec", ";", "if", "(", "End", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found Loop End: ", "<STR_LIT>", "<<", "*", "End", ";", "if", "(", "VCTP", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found VCTP: ", "<STR_LIT>", "<<", "*", "VCTP", ";", "if", "(", "!", "FoundAllComponents", "(", ")", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Not a low-overhead loop.\\n", "<STR_LIT>", ";", "else", "if", "(", "!", "(", "Start", "&&", "Dec", "&&", "End", ")", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Failed to find all loop components.\\n", "<STR_LIT>", ";", "}" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "}" ]

[ "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", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

[ "static", "bool", "arm_fastmul_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "*", "total", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "TARGET_THUMB", ")", "{", "*", "total", "=", "thumb_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "switch", "(", "code", ")", "{", "case", "MULT", ":", "if", "(", "mode", "==", "DImode", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "SIGN_EXTEND", ")", ")", "{", "*", "total", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "DImode", ")", "{", "*", "total", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "i", "=", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", ")", ";", "int", "cost", ",", "const_ok", "=", "const_ok_for_arm", "(", "i", ")", ";", "int", "j", ",", "booth_unit_size", ";", "cost", "=", "const_ok", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "booth_unit_size", "=", "<NUM_LIT>", ";", "for", "(", "j", "=", "<NUM_LIT>", ";", "i", "&&", "j", "<", "<NUM_LIT>", ";", "j", "+=", "booth_unit_size", ")", "{", "i", ">>=", "booth_unit_size", ";", "cost", "+=", "<NUM_LIT>", ";", "}", "*", "total", "=", "cost", ";", "return", "true", ";", "}", "*", "total", "=", "<NUM_LIT>", "+", "(", "REG_OR_SUBREG_REG", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "+", "(", "REG_OR_SUBREG_REG", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "default", ":", "*", "total", "=", "arm_rtx_costs_1", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "}" ]

[ "RTX", "cost", "for", "cores", "with", "a", "fast", "multiply", "unit", "(", "M", "variants", ")", "." ]