Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "ia64_sysv4_init_libfuncs", "(", "void", ")", "{", "ia64_init_libfuncs", "(", ")", ";", "set_optab_libfunc", "(", "eq_optab", ",", "TFmode", ",", "\"_U_Qfeq\"", ")", ";", "set_optab_libfunc", "(", "ne_optab", ",", "TFmode", ",", "\"_U_Qfne\"", ")", ";", "set_optab_libfunc", "(", "gt_optab", ",", "TFmode", ",", "\"_U_Qfgt\"", ")", ";", "set_optab_libfunc", "(", "ge_optab", ",", "TFmode", ",", "\"_U_Qfge\"", ")", ";", "set_optab_libfunc", "(", "lt_optab", ",", "TFmode", ",", "\"_U_Qflt\"", ")", ";", "set_optab_libfunc", "(", "le_optab", ",", "TFmode", ",", "\"_U_Qfle\"", ")", ";", "}", "</s>" ]

[ "Rename", "the", "TFmode", "libfuncs", "available", "from", "soft-fp", "in", "glibc", "using", "the", "HPUX", "conventions", "." ]

[ "ia64", "\"_U_Qfeq\"", "\"_U_Qfne\"", "\"_U_Qfgt\"", "\"_U_Qfge\"", "\"_U_Qflt\"", "\"_U_Qfle\"" ]

[]

[ "<s>", "static", "rtx", "mep_legitimize_arg", "(", "const", "struct", "insn_operand_data", "*", "operand", ",", "rtx", "arg", ",", "int", "unsigned_p", ")", "{", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_INT", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "operand", "->", "mode", ")", "!=", "MODE_INT", ")", "return", "0", ";", "}", "else", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_DOUBLE", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "arg", ")", ")", "!=", "GET_MODE_SIZE", "(", "operand", "->", "mode", ")", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "operand", "->", "mode", ")", "!=", "GET_MODE_CLASS", "(", "GET_MODE", "(", "arg", ")", ")", ")", "return", "0", ";", "if", "(", "operand", "->", "constraint", "[", "0", "]", "!=", "'='", ")", "arg", "=", "convert_to_mode", "(", "operand", "->", "mode", ",", "arg", ",", "unsigned_p", ")", ";", "}", "if", "(", "operand", "->", "constraint", "[", "0", "]", "==", "'='", "&&", "(", "!", "REG_P", "(", "arg", ")", "||", "!", "(", "CONTROL_REGNO_P", "(", "REGNO", "(", "arg", ")", ")", "||", "CCR_REGNO_P", "(", "REGNO", "(", "arg", ")", ")", "||", "CR_REGNO_P", "(", "REGNO", "(", "arg", ")", ")", ")", ")", ")", "return", "gen_reg_rtx", "(", "operand", "->", "mode", ")", ";", "arg", "=", "mep_convert_arg", "(", "operand", "->", "mode", ",", "arg", ")", ";", "if", "(", "operand", "->", "predicate", "(", "arg", ",", "operand", "->", "mode", ")", ")", "return", "arg", ";", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "arg", ")", "==", "CONST_DOUBLE", ")", "arg", "=", "force_reg", "(", "operand", "->", "mode", ",", "arg", ")", ";", "else", "arg", "=", "mep_convert_arg", "(", "operand", "->", "mode", ",", "force_reg", "(", "GET_MODE", "(", "arg", ")", ",", "arg", ")", ")", ";", "if", "(", "operand", "->", "predicate", "(", "arg", ",", "operand", "->", "mode", ")", ")", "return", "arg", ";", "return", "0", ";", "}", "</s>" ]

[ "Try", "to", "make", "intrinsic", "argument", "ARG", "match", "the", "given", "operand", ".", "UNSIGNED_P", "is", "true", "if", "the", "argument", "has", "an", "unsigned", "type", "." ]

[ "mep", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'r'", ":", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "NVPTX", "NVPTX", "0", "1", "0", "0" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "SDValue", "HexagonSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "AlwaysInline", "||", "(", "Align", "&", "0x3", ")", "!=", "0", "||", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "SizeVal", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "if", "(", "SizeVal", "<", "32", "||", "(", "SizeVal", "%", "8", ")", "!=", "0", ")", "return", "SDValue", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "const", "char", "*", "SpecialMemcpyName", "=", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", ";", "const", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "bool", "LongCalls", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "useLongCalls", "(", ")", ";", "unsigned", "Flags", "=", "LongCalls", "?", "HexagonII", "::", "HMOTF_ConstExtended", ":", "0", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getTargetExternalSymbol", "(", "SpecialMemcpyName", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ",", "Flags", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "Hexagon", "Hexagon", "0x3", "0", "32", "8", "0", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", "Hexagon", "HexagonII::HMOTF_ConstExtended", "0" ]

[]

[ "<s>", "int", "eligible_for_sibcall_delay", "(", "rtx", "trial", ")", "{", "rtx", "pat", ";", "if", "(", "GET_CODE", "(", "trial", ")", "!=", "INSN", "||", "GET_CODE", "(", "PATTERN", "(", "trial", ")", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "get_attr_length", "(", "trial", ")", "!=", "1", ")", "return", "0", ";", "pat", "=", "PATTERN", "(", "trial", ")", ";", "if", "(", "sparc_leaf_function_p", ")", "{", "if", "(", "LEAF_SIBCALL_SLOT_RESERVED_P", ")", "return", "0", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "pat", ")", ")", "return", "0", ";", "return", "1", ";", "}", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "REG", "||", "(", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ">=", "8", "&&", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", "<", "24", ")", "||", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ">=", "32", ")", "return", "0", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "Pmode", ",", "15", ")", ",", "pat", ")", ")", "return", "0", ";", "return", "eligible_for_restore_insn", "(", "trial", ",", "false", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "TRIAL", "can", "go", "into", "the", "sibling", "call", "'s", "delay", "slot", "." ]

[ "sparc", "0", "1", "0", "0", "1", "0", "1", "8", "24", "32", "0", "15", "0" ]

[]

[ "<s>", "bool", "TPCInstrCompress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "MF", "=", "&", "Fn", ";", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "ItinData", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrItineraryData", "(", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n*** TPC Inst Compression\\n\"", ")", ";", "prevMI", "=", "nullptr", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Processing BB#\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "MBB", ".", "empty", "(", ")", ")", "{", "continue", ";", "}", "processBB", "(", "MBB", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "TPC", "TPC", "\"\\n*** TPC Inst Compression\\n\"", "\"Processing BB#\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "F", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Sparc" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_vec_set_builtin", "(", "tree", "exp", ")", "{", "machine_mode", "tmode", ",", "mode1", ";", "tree", "arg0", ",", "arg1", ",", "arg2", ";", "int", "elt", ";", "rtx", "op0", ",", "op1", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "arg2", "=", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ";", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "mode1", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "tmode", ",", "EXPAND_NORMAL", ")", ";", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "mode1", ",", "EXPAND_NORMAL", ")", ";", "elt", "=", "get_element_number", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg2", ")", ";", "if", "(", "GET_MODE", "(", "op1", ")", "!=", "mode1", "&&", "GET_MODE", "(", "op1", ")", "!=", "VOIDmode", ")", "op1", "=", "convert_modes", "(", "mode1", ",", "GET_MODE", "(", "op1", ")", ",", "op1", ",", "true", ")", ";", "op0", "=", "force_reg", "(", "tmode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "mode1", ",", "op1", ")", ";", "rs6000_expand_vector_set", "(", "op0", ",", "op1", ",", "elt", ")", ";", "return", "op0", ";", "}", "</s>" ]

[ "Expand", "vec_set", "builtin", "." ]

[ "rs6000", "0", "1", "2" ]

[]

[ "<s>", "const", "char", "*", "ARCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "ARCISD", "::", "BL", ":", "return", "\"ARCISD::BL\"", ";", "case", "ARCISD", "::", "CMOV", ":", "return", "\"ARCISD::CMOV\"", ";", "case", "ARCISD", "::", "CMP", ":", "return", "\"ARCISD::CMP\"", ";", "case", "ARCISD", "::", "BRcc", ":", "return", "\"ARCISD::BRcc\"", ";", "case", "ARCISD", "::", "RET", ":", "return", "\"ARCISD::RET\"", ";", "case", "ARCISD", "::", "GAWRAPPER", ":", "return", "\"ARCISD::GAWRAPPER\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "ARC", "ARC", "ARCISD::BL", "\"ARCISD::BL\"", "ARCISD::CMOV", "\"ARCISD::CMOV\"", "ARCISD::CMP", "\"ARCISD::CMP\"", "ARCISD::BRcc", "\"ARCISD::BRcc\"", "ARCISD::RET", "\"ARCISD::RET\"", "ARCISD::GAWRAPPER", "\"ARCISD::GAWRAPPER\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableAArch64CopyPropagation", ")", "addPass", "(", "createMachineCopyPropagationPass", "(", "true", ")", ")", ";", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "bool", "Is64Bit", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR32", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR32", ")", "{", "++", "I", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"TLS Dynamic Call Fixup:\\n \"", "<<", "MI", ")", ";", "unsigned", "OutReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "InReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "GPR3", "=", "Is64Bit", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "unsigned", "Opc1", ",", "Opc2", ";", "const", "unsigned", "OrigRegs", "[", "]", "=", "{", "OutReg", ",", "InReg", ",", "GPR3", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode inconsistency error\"", ")", ";", "case", "PPC", "::", "ADDItlsgdLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsgdLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL32", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR32", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL32", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR32", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKDOWN", ")", ")", ".", "addImm", "(", "0", ")", ";", "MachineInstr", "*", "Addi", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc1", ")", ",", "GPR3", ")", ".", "addReg", "(", "InReg", ")", ";", "Addi", "->", "addOperand", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "First", "=", "I", ";", "--", "First", ";", "MachineInstr", "*", "Call", "=", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc2", ")", ",", "GPR3", ")", ".", "addReg", "(", "GPR3", ")", ")", ";", "Call", "->", "addOperand", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKUP", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "OutReg", ")", ".", "addReg", "(", "GPR3", ")", ";", "MachineBasicBlock", "::", "iterator", "Last", "=", "I", ";", "--", "Last", ";", "++", "I", ";", "MI", ".", "removeFromParent", "(", ")", ";", "LIS", "->", "repairIntervalsInRange", "(", "&", "MBB", ",", "First", ",", "Last", ",", "OrigRegs", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsldLADDR32", "\"TLS Dynamic Call Fixup:\\n \"", "0", "1", "PPC::X3", "PPC::R3", "\"Opcode inconsistency error\"", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsgdL", "PPC::GETtlsADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsldL", "PPC::GETtlsldADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsgdL32", "PPC::GETtlsADDR32", "PPC::ADDItlsldLADDR32", "PPC::ADDItlsldL32", "PPC::GETtlsldADDR32", "PPC::ADJCALLSTACKDOWN", "0", "2", "3", "PPC::ADJCALLSTACKUP", "0", "0" ]

[]

[ "<s>", "int", "SIInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16Buf", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "{", "switch", "(", "ST", ".", "getGeneration", "(", ")", ")", "{", "default", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX9", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA9", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX10", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA10", ";", "break", ";", "}", "}", "if", "(", "isMAI", "(", "Opcode", ")", ")", "{", "int", "MFMAOp", "=", "AMDGPU", "::", "getMFMAEarlyClobberOp", "(", "Opcode", ")", ";", "if", "(", "MFMAOp", "!=", "-", "1", ")", "Opcode", "=", "MFMAOp", ";", "}", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "{", "uint16_t", "NMCOp", "=", "(", "uint16_t", ")", "-", "1", ";", "if", "(", "ST", ".", "hasGFX940Insts", "(", ")", ")", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX940", ")", ";", "if", "(", "NMCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX90A", ")", ";", "if", "(", "NMCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX9", ")", ";", "if", "(", "NMCOp", "!=", "(", "uint16_t", ")", "-", "1", ")", "MCOp", "=", "NMCOp", ";", "}", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "if", "(", "isAsmOnlyOpcode", "(", "MCOp", ")", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "SI", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::D16Buf", "SIEncodingFamily::GFX80", "SIInstrFlags::SDWA", "SIEncodingFamily::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "AMDGPU", "SIEncodingFamily::SDWA10", "AMDGPU::getMFMAEarlyClobberOp", "1", "AMDGPU::getMCOpcode", "1", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX940", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX90A", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX9", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "ix86_emit_leave", "(", "void", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "insn", "=", "emit_insn", "(", "ix86_gen_leave", "(", ")", ")", ";", "ix86_add_queued_cfa_restore_notes", "(", "insn", ")", ";", "gcc_assert", "(", "m", "->", "fs", ".", "fp_valid", ")", ";", "m", "->", "fs", ".", "sp_valid", "=", "true", ";", "m", "->", "fs", ".", "sp_offset", "=", "m", "->", "fs", ".", "fp_offset", "-", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "fp_valid", "=", "false", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "cfa_reg", "=", "stack_pointer_rtx", ";", "m", "->", "fs", ".", "cfa_offset", "=", "m", "->", "fs", ".", "sp_offset", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "m", "->", "fs", ".", "sp_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "ix86_add_cfa_restore_note", "(", "insn", ",", "hard_frame_pointer_rtx", ",", "m", "->", "fs", ".", "fp_offset", ")", ";", "}", "</s>" ]

[ "Emit", "code", "and", "notes", "for", "the", "LEAVE", "instruction", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "HexagonDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Inp", "=", "Op", ",", "Res", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "return", "true", ";", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_v", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "SelectAddrFI", "(", "Inp", ",", "Res", ")", ")", "OutOps", ".", "push_back", "(", "Res", ")", ";", "else", "OutOps", ".", "push_back", "(", "Inp", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "Hexagon", "Hexagon", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "::", "ArgumentListType", "&", "Args", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumArgs", "=", "Args", ".", "size", "(", ")", ";", "Function", "::", "const_arg_iterator", "CurOrigArg", "=", "Args", ".", "begin", "(", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumArgs", ";", "++", "i", ",", "++", "CurOrigArg", ")", "{", "MVT", "ValVT", "=", "MVT", "::", "getVT", "(", "CurOrigArg", "->", "getType", "(", ")", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "bool", "Res", "=", "AssignFn", "(", "i", ",", "ValVT", ",", "ValVT", ",", "CCValAssign", "::", "Full", ",", "ISD", "::", "ArgFlagsTy", "(", ")", ",", "CCInfo", ")", ";", "assert", "(", "!", "Res", "&&", "\"Call operand has unhandled type\"", ")", ";", "(", "void", ")", "Res", ";", "}", "assert", "(", "ArgLocs", ".", "size", "(", ")", "==", "Args", ".", "size", "(", ")", "&&", "\"We have a different number of location and args?!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Not yet implemented\"", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "VRegs", "[", "i", "]", ",", "VA", ".", "getLocReg", "(", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "assert", "(", "0", "&&", "\"Not yet implemented\"", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "16", "AArch64", "AArch64", "0", "MVT::getVT", "ISD::ArgFlagsTy", "\"Call operand has unhandled type\"", "\"We have a different number of location and args?!\"", "0", "\"Not yet implemented\"", "\"Unknown loc info!\"", "0", "\"Not yet implemented\"" ]

[]

[ "<s>", "static", "bool", "xtensa_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "return", "constantpool_address_p", "(", "addr", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_MODE_DEPENDENT_ADDRESS_P", ".", "Treat", "constant-pool", "references", "as", "``", "mode", "dependent", "''", "since", "they", "can", "only", "be", "accessed", "with", "SImode", "loads", ".", "This", "works", "around", "a", "bug", "in", "the", "combiner", "where", "a", "constant", "pool", "reference", "is", "temporarily", "converted", "to", "an", "HImode", "load", ",", "which", "is", "then", "assumed", "to", "zero-extend", "based", "on", "our", "definition", "of", "LOAD_EXTEND_OP", ".", "This", "is", "wrong", "because", "the", "high", "bits", "of", "a", "16-bit", "value", "in", "the", "constant", "pool", "are", "now", "sign-extended", "by", "default", "." ]

[ "xtensa" ]

[]

[ "<s>", "bool", "TPCResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "savePacket", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "savePacket", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "if", "(", "!", "SU", "->", "getInstr", "(", ")", "->", "isPseudo", "(", ")", ")", "{", "ResourcesModel", "->", "reserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "Packet", ".", "push_back", "(", "SU", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "LLVM_DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "if", "(", "Packet", ".", "size", "(", ")", ">=", "4", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "savePacket", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]

[ "Keep", "track", "of", "available", "resources", "." ]

[ "TPC", "TPC", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"", "4" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "DL", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "&", "Args", "=", "F", ".", "getArgumentList", "(", ")", ";", "unsigned", "ArgIdx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgIdx", "++", ";", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "ArgIdx", ">", "4", "&&", "Arg", ".", "getType", "(", ")", "->", "getIntegerBitWidth", "(", ")", "!=", "32", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "1", ",", "DL", ",", "F", ")", ";", "ArgInfos", ".", "push_back", "(", "AInfo", ")", ";", "Idx", "++", ";", "}", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "AssignFn", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "0", "4", "32", "8", "0", "1" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SETCC", ":", "{", "SDValue", "Arg0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Arg1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "CC", "=", "N", "->", "getOperand", "(", "2", ")", ";", "ConstantSDNode", "*", "C", "=", "nullptr", ";", "ISD", "::", "CondCode", "CCOp", "=", "dyn_cast", "<", "CondCodeSDNode", ">", "(", "CC", ")", "->", "get", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "Arg0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "&&", "Arg0", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", "&&", "(", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Arg1", ")", ")", "&&", "C", "->", "isNullValue", "(", ")", "&&", "CCOp", "==", "ISD", "::", "SETNE", ")", "{", "return", "SimplifySetCC", "(", "VT", ",", "Arg0", ".", "getOperand", "(", "0", ")", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i1", ")", ",", "CCOp", ",", "true", ",", "DCI", ",", "DL", ")", ";", "}", "break", ";", "}", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE0", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE1", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE2", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE3", ":", "{", "unsigned", "Offset", "=", "N", "->", "getOpcode", "(", ")", "-", "AMDGPUISD", "::", "CVT_F32_UBYTE0", ";", "SDValue", "Src", "=", "N", "->", "getOperand", "(", "0", ")", ";", "APInt", "Demanded", "=", "APInt", "::", "getBitsSet", "(", "32", ",", "8", "*", "Offset", ",", "8", "*", "Offset", "+", "8", ")", ";", "APInt", "KnownZero", ",", "KnownOne", ";", "TargetLowering", "::", "TargetLoweringOpt", "TLO", "(", "DAG", ",", "!", "DCI", ".", "isBeforeLegalize", "(", ")", ",", "!", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "TLO", ".", "ShrinkDemandedConstant", "(", "Src", ",", "Demanded", ")", "||", "TLI", ".", "SimplifyDemandedBits", "(", "Src", ",", "Demanded", ",", "KnownZero", ",", "KnownOne", ",", "TLO", ")", ")", "{", "DCI", ".", "CommitTargetLoweringOpt", "(", "TLO", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "UINT_TO_FP", ":", "{", "return", "performUCharToFloatCombine", "(", "N", ",", "DCI", ")", ";", "}", "}", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "R600", "SI", "0", "ISD::SETCC", "0", "1", "2", "ISD::CondCode", "MVT::i1", "ISD::SIGN_EXTEND", "0", "MVT::i1", "ISD::SETNE", "0", "0", "MVT::i1", "AMDGPUISD::CVT_F32_UBYTE0", "AMDGPUISD::CVT_F32_UBYTE1", "AMDGPUISD::CVT_F32_UBYTE2", "AMDGPUISD::CVT_F32_UBYTE3", "AMDGPUISD::CVT_F32_UBYTE0", "0", "32", "8", "8", "8", "ISD::UINT_TO_FP" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "const", "MachineOperand", "&", "BaseOp1", ",", "const", "MachineOperand", "&", "BaseOp2", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "BaseOp1", ".", "getType", "(", ")", "!=", "BaseOp2", ".", "getType", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "BaseOp1", ".", "isReg", "(", ")", "||", "BaseOp1", ".", "isFI", "(", ")", ")", "&&", "\"Only base registers and frame indices are supported.\"", ")", ";", "if", "(", "BaseOp1", ".", "isReg", "(", ")", "&&", "BaseOp1", ".", "getReg", "(", ")", "!=", "BaseOp2", ".", "getReg", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">", "1", ")", "return", "false", ";", "if", "(", "!", "isPairableLdStInst", "(", "FirstLdSt", ")", "||", "!", "isPairableLdStInst", "(", "SecondLdSt", ")", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "if", "(", "BaseOp1", ".", "isFI", "(", ")", ")", "{", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", ">=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFrameInfo", "(", ")", ";", "return", "shouldClusterFI", "(", "MFI", ",", "BaseOp1", ".", "getIndex", "(", ")", ",", "Offset1", ",", "FirstOpc", ",", "BaseOp2", ".", "getIndex", "(", ")", ",", "Offset2", ",", "SecondOpc", ")", ";", "}", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", "<=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AArch64", "AArch64", "\"Only base registers and frame indices are supported.\"", "1", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "static", "constexpr", "ArgDescriptor", "createRegister", "(", "Register", "Reg", ",", "unsigned", "Mask", "=", "~", "0u", ")", "{", "return", "ArgDescriptor", "(", "Reg", ",", "Mask", ",", "false", ",", "true", ")", ";", "}", "</s>" ]

[ ".cfi_register", "Previous", "value", "of", "Register1", "is", "saved", "in", "register", "Register2", "." ]

[ "AMDGPU", "0u" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Load / Store Optimizer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "AMDGPU", "\"SI Load / Store Optimizer\"" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_loadwb_pair", "(", "machine_mode", "mode", ",", "rtx", "base", ",", "rtx", "reg", ",", "rtx", "reg2", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "switch", "(", "mode", ")", "{", "case", "DImode", ":", "return", "gen_loadwb_pairdi_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "case", "DFmode", ":", "return", "gen_loadwb_pairdf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "pair", "of", "register", "REG", ",", "REG2", "of", "mode", "MODE", "from", "stack", "location", "BASE", ",", "adjusting", "it", "by", "ADJUSTMENT", "afterwards", "." ]

[ "aarch64" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "IntRegsRegClass", "}", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", "}", ";", "}", "break", ";", "case", "'a'", ":", "if", "(", "VT", "!=", "MVT", "::", "i32", ")", "return", "{", "0u", ",", "nullptr", "}", ";", "return", "{", "0u", ",", "&", "Hexagon", "::", "ModRegsRegClass", "}", ";", "case", "'q'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "512", ":", "case", "1024", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxQRRegClass", "}", ";", "}", "break", ";", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "512", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxVRRegClass", "}", ";", "case", "1024", ":", "if", "(", "Subtarget", ".", "hasV60Ops", "(", ")", "&&", "Subtarget", ".", "useHVX128BOps", "(", ")", ")", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxVRRegClass", "}", ";", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxWRRegClass", "}", ";", "case", "2048", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxWRRegClass", "}", ";", "}", "break", ";", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "Hexagon", "Hexagon", "1", "0", "0u", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f32", "0u", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "0u", "Hexagon::DoubleRegsRegClass", "MVT::i32", "0u", "0u", "Hexagon::ModRegsRegClass", "0u", "512", "1024", "0u", "Hexagon::HvxQRRegClass", "0u", "512", "0u", "Hexagon::HvxVRRegClass", "1024", "0u", "Hexagon::HvxVRRegClass", "0u", "Hexagon::HvxWRRegClass", "2048", "0u", "Hexagon::HvxWRRegClass", "0u" ]

[]

[ "<s>", "unsigned", "getMaxCallFrameSize", "(", ")", "const", "{", "return", "MaxCallFrameSize", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "size", "of", "a", "call", "frame", "that", "must", "be", "allocated", "for", "an", "outgoing", "function", "call", "." ]

[ "LC3b" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "AllSGPRSpilledToVGPRs", "=", "false", ";", "if", "(", "TRI", ".", "spillSGPRToVGPR", "(", ")", "&&", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", "{", "AllSGPRSpilledToVGPRs", "=", "true", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "{", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "bool", "Spilled", "=", "TRI", ".", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "RS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "}", "else", "AllSGPRSpilledToVGPRs", "=", "false", ";", "}", "}", "}", "}", "FuncInfo", "->", "removeSGPRToVGPRFrameIndices", "(", "MFI", ")", ";", "if", "(", "FuncInfo", "->", "hasNonSpillStackObjects", "(", ")", "||", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "||", "!", "AllSGPRSpilledToVGPRs", "||", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "else", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateStackObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "TRI", ".", "getSpillAlignment", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::OpName", "\"failed to spill SGPR to VGPR when allocated\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "TargetPassConfig", "*", "Z80oldTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "Z80oldPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Z80old", "Z80old", "Z80old" ]

[]

[ "<s>", "static", "void", "frv_optimize_membar", "(", "void", ")", "{", "basic_block", "bb", ";", "struct", "frv_io", "*", "first_io", ";", "rtx", "*", "last_membar", ";", "compute_bb_for_insn", "(", ")", ";", "first_io", "=", "xcalloc", "(", "last_basic_block", ",", "sizeof", "(", "struct", "frv_io", ")", ")", ";", "last_membar", "=", "xcalloc", "(", "last_basic_block", ",", "sizeof", "(", "rtx", ")", ")", ";", "FOR_EACH_BB", "(", "bb", ")", "frv_optimize_membar_local", "(", "bb", ",", "&", "first_io", "[", "bb", "->", "index", "]", ",", "&", "last_membar", "[", "bb", "->", "index", "]", ")", ";", "FOR_EACH_BB", "(", "bb", ")", "if", "(", "last_membar", "[", "bb", "->", "index", "]", "!=", "0", ")", "frv_optimize_membar_global", "(", "bb", ",", "first_io", ",", "last_membar", "[", "bb", "->", "index", "]", ")", ";", "free", "(", "first_io", ")", ";", "free", "(", "last_membar", ")", ";", "}", "</s>" ]

[ "Remove", "redundant", "membars", "from", "the", "current", "function", "." ]

[ "frv", "0" ]

[]

[ "<s>", "rtx", "loongarch_prefetch_cookie", "(", "rtx", "write", ",", "rtx", "locality", ")", "{", "if", "(", "INTVAL", "(", "locality", ")", "<=", "0", ")", "return", "GEN_INT", "(", "INTVAL", "(", "write", ")", "+", "4", ")", ";", "if", "(", "INTVAL", "(", "locality", ")", "<=", "2", ")", "return", "write", ";", "return", "GEN_INT", "(", "INTVAL", "(", "write", ")", "+", "6", ")", ";", "}", "</s>" ]

[ "Given", "that", "we", "have", "an", "rtx", "of", "the", "form", "(", "prefetch", "...", "WRITE", "LOCALITY", ")", ",", "return", "the", "first", "operand", "of", "the", "associated", "PREF", "or", "PREFX", "insn", "." ]

[ "loongarch", "0", "4", "2", "6" ]

[]

[ "<s>", "static", "void", "csky_output_pic_addr_const", "(", "FILE", "*", "stream", ",", "rtx", "x", ",", "int", "code", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "UNSPEC", ")", "return", ";", "if", "(", "UNSPEC_TLS", "==", "XINT", "(", "x", ",", "1", ")", ")", "{", "return", ";", "}", "csky_print_operand", "(", "stream", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ",", "code", ")", ";", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_PIC_SYMBOL_GOTOFF", ":", "fputs", "(", "\"@GOTOFF\"", ",", "stream", ")", ";", "break", ";", "case", "UNSPEC_PIC_SYMBOL_PLT", ":", "fputs", "(", "\"@PLT\"", ",", "stream", ")", ";", "break", ";", "case", "UNSPEC_PIC_SYMBOL_GOT", ":", "fputs", "(", "\"@GOT\"", ",", "stream", ")", ";", "break", ";", "case", "UNSPEC_PIC_SYMBOL_GOTPC", ":", "fputs", "(", "\"@GOTPC\"", ",", "stream", ")", ";", "break", ";", "case", "UNSPEC_PIC_SYMBOL_BSR", ":", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "UNSPEC", "operand", "in", "X", "to", "the", "STREAM", "." ]

[ "csky", "1", "0", "0", "1", "\"@GOTOFF\"", "\"@PLT\"", "\"@GOT\"", "\"@GOTPC\"" ]

[]

[ "<s>", "void", "DCPU16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DCPU16MachineFunctionInfo", "*", "DCPU16FI", "=", "MF", ".", "getInfo", "<", "DCPU16MachineFunctionInfo", ">", "(", ")", ";", "const", "DCPU16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "DCPU16InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "DCPU16FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "DCPU16", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "DCPU16", "::", "J", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "DCPU16", "::", "MOV16rr", ")", ",", "DCPU16", "::", "J", ")", ".", "addReg", "(", "DCPU16", "::", "SP", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "DCPU16", "::", "J", ")", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "DCPU16", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "DCPU16", "::", "SUB16ri", ")", ",", "DCPU16", "::", "SP", ")", ".", "addReg", "(", "DCPU16", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Dcpu16", "DCPU16", "DCPU16", "DCPU16", "DCPU16", "DCPU16", "DCPU16", "DCPU16", "DCPU16::PUSH16r", "DCPU16::J", "DCPU16::MOV16rr", "DCPU16::J", "DCPU16::SP", "DCPU16::J", "DCPU16::PUSH16r", "DCPU16::SUB16ri", "DCPU16::SP", "DCPU16::SP", "3" ]

[]

[ "<s>", "void", "MOSMCELFStreamer", "::", "initSections", "(", "bool", "NoExecStack", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "MCContext", "&", "Ctx", "=", "getContext", "(", ")", ";", "SwitchSection", "(", "Ctx", ".", "getObjectFileInfo", "(", ")", "->", "getTextSection", "(", ")", ")", ";", "emitCodeAlignment", "(", "1", ",", "&", "STI", ")", ";", "if", "(", "NoExecStack", ")", "SwitchSection", "(", "Ctx", ".", "getAsmInfo", "(", ")", "->", "getNonexecutableStackSection", "(", "Ctx", ")", ")", ";", "}", "</s>" ]

[ "Create", "the", "default", "sections", "and", "set", "the", "initial", "one", "." ]

[ "MOS", "MOS", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "decomposeMulByConstant", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "SDValue", "C", ")", "const", "{", "if", "(", "VT", ".", "isScalarInteger", "(", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtM", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "ConstNode", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "C", ".", "getNode", "(", ")", ")", ")", "{", "if", "(", "ConstNode", "->", "getAPIntValue", "(", ")", ".", "getBitWidth", "(", ")", ">", "8", "*", "sizeof", "(", "int64_t", ")", ")", "return", "false", ";", "int64_t", "Imm", "=", "ConstNode", "->", "getSExtValue", "(", ")", ";", "if", "(", "isPowerOf2_64", "(", "Imm", "+", "1", ")", "||", "isPowerOf2_64", "(", "Imm", "-", "1", ")", "||", "isPowerOf2_64", "(", "1", "-", "Imm", ")", "||", "isPowerOf2_64", "(", "-", "1", "-", "Imm", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "transform", "an", "integer", "multiplication-by-constant", "into", "simpler", "operations", "like", "shifts", "and", "adds", "." ]

[ "RISCV", "RISCV", "8", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86InstructionSelector", "::", "getRegClass", "(", "LLT", "Ty", ",", "unsigned", "Reg", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "const", "RegisterBank", "&", "RegBank", "=", "*", "RBI", ".", "getRegBank", "(", "Reg", ",", "MRI", ",", "TRI", ")", ";", "return", "getRegClass", "(", "Ty", ",", "RegBank", ")", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "initialize", "(", "MF", ")", ";", "return", "simplifyCode", "(", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "PowerPC" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createRISCVObjectWriter", "(", "OS", ",", "OSABI", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "struct", "rtx_def", "*", "clipper_builtin_saveregs", "(", ")", "{", "rtx", "block", ",", "addr", ",", "r0_addr", ",", "r1_addr", ",", "f0_addr", ",", "f1_addr", ",", "mem", ";", "int", "set", "=", "get_varargs_alias_set", "(", ")", ";", "block", "=", "assign_stack_local", "(", "BLKmode", ",", "6", "*", "UNITS_PER_WORD", ",", "2", "*", "BITS_PER_WORD", ")", ";", "RTX_UNCHANGING_P", "(", "block", ")", "=", "1", ";", "RTX_UNCHANGING_P", "(", "XEXP", "(", "block", ",", "0", ")", ")", "=", "1", ";", "addr", "=", "XEXP", "(", "block", ",", "0", ")", ";", "r0_addr", "=", "addr", ";", "r1_addr", "=", "plus_constant", "(", "addr", ",", "4", ")", ";", "f0_addr", "=", "plus_constant", "(", "addr", ",", "8", ")", ";", "f1_addr", "=", "plus_constant", "(", "addr", ",", "16", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "r0_addr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "r1_addr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "1", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DFmode", ",", "f0_addr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "DFmode", ",", "16", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DFmode", ",", "f1_addr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "DFmode", ",", "17", ")", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Dump", "the", "argument", "register", "to", "the", "stack", ";", "return", "the", "location", "of", "the", "block", "." ]

[ "clipper", "6", "2", "1", "0", "1", "0", "4", "8", "16", "0", "1", "16", "17" ]

[]

[ "<s>", "bool", "ARMTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createARMISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "areLoadsFromSameBasePtr", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "&", "Offset1", ",", "int64_t", "&", "Offset2", ")", "const", "{", "if", "(", "!", "Load1", "->", "isMachineOpcode", "(", ")", "||", "!", "Load2", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "unsigned", "Opc1", "=", "Load1", "->", "getMachineOpcode", "(", ")", ";", "unsigned", "Opc2", "=", "Load2", "->", "getMachineOpcode", "(", ")", ";", "switch", "(", "Opc1", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp32m", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "LD_Fp80m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVUPSrm_Int", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MOVDQUrm", ":", "case", "X86", "::", "MOVDQUrm_Int", ":", "break", ";", "}", "switch", "(", "Opc2", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp32m", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "LD_Fp80m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVUPSrm_Int", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MOVDQUrm", ":", "case", "X86", "::", "MOVDQUrm_Int", ":", "break", ";", "}", "if", "(", "Load1", "->", "getOperand", "(", "0", ")", "!=", "Load2", "->", "getOperand", "(", "0", ")", "||", "Load1", "->", "getOperand", "(", "5", ")", "!=", "Load2", "->", "getOperand", "(", "5", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "4", ")", "!=", "Load2", "->", "getOperand", "(", "4", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "1", ")", "==", "Load2", "->", "getOperand", "(", "1", ")", "&&", "Load1", "->", "getOperand", "(", "2", ")", "==", "Load2", "->", "getOperand", "(", "2", ")", ")", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "3", ")", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "3", ")", ")", ")", "{", "Offset1", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "3", ")", ")", "->", "getSExtValue", "(", ")", ";", "Offset2", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "3", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "areLoadsFromSameBasePtr", "-", "This", "is", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "if", "two", "loads", "are", "loading", "from", "the", "same", "base", "address", "." ]

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp32m", "X86::LD_Fp64m", "X86::LD_Fp80m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVUPSrm_Int", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MOVDQUrm", "X86::MOVDQUrm_Int", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp32m", "X86::LD_Fp64m", "X86::LD_Fp80m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVUPSrm_Int", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MOVDQUrm", "X86::MOVDQUrm_Int", "0", "0", "5", "5", "4", "4", "1", "1", "2", "2", "1", "1", "3", "3", "3", "3" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "LoadOpcode", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "!", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "return", "ARMBaseInstrInfo", "::", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tMOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "ARM", "ARM::GPRRegClass", "ARM", "ARM::tMOVr" ]

[]

[ "<s>", "bool", "e8_consumed_by_addr_in_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "return", "n8_consumed_by_addr_in_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "AG", "(", "II", ")", "." ]

[ "nds32" ]

[]

[ "<s>", "void", "dump", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "int", "depth", "=", "0", ")", "override", "{", "dumpDepth", "(", "depth", ")", ";", "dbgs", "(", ")", "<<", "\"Region: \"", "<<", "(", "void", "*", ")", "Region", ";", "dbgs", "(", ")", "<<", "\" In: \"", "<<", "PrintReg", "(", "getBBSelectRegIn", "(", ")", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\", Out: \"", "<<", "PrintReg", "(", "getBBSelectRegOut", "(", ")", ",", "TRI", ")", "<<", "\"\\n\"", ";", "dumpDepth", "(", "depth", ")", ";", "if", "(", "getSucc", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Succ: \"", "<<", "getSucc", "(", ")", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ";", "else", "dbgs", "(", ")", "<<", "\"Succ: none \\n\"", ";", "for", "(", "auto", "MRTI", ":", "Children", ")", "{", "MRTI", "->", "dump", "(", "TRI", ",", "depth", "+", "1", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "0", "\"Region: \"", "\" In: \"", "\", Out: \"", "\"\\n\"", "\"Succ: \"", "\"\\n\"", "\"Succ: none \\n\"", "1" ]

[]

[ "<s>", "int", "arm_debugger_arg_offset", "(", "int", "value", ",", "rtx", "addr", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "value", "!=", "0", ")", "return", "0", ";", "if", "(", "!", "REG_P", "(", "addr", ")", ")", "return", "0", ";", "if", "(", "REGNO", "(", "addr", ")", "==", "(", "unsigned", ")", "HARD_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "if", "(", "(", "TARGET_THUMB", "||", "!", "frame_pointer_needed", ")", "&&", "REGNO", "(", "addr", ")", "==", "SP_REGNUM", ")", "return", "0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "REGNO", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ")", "==", "REGNO", "(", "addr", ")", "&&", "GET_CODE", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "0", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "0", ")", ")", "==", "(", "unsigned", ")", "HARD_FRAME_POINTER_REGNUM", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "1", ")", ")", ")", "{", "value", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "1", ")", ")", ";", "break", ";", "}", "}", "if", "(", "value", "==", "0", ")", "{", "debug_rtx", "(", "addr", ")", ";", "warning", "(", "0", ",", "\"unable to compute real location of stacked parameter\"", ")", ";", "value", "=", "8", ";", "}", "return", "value", ";", "}", "</s>" ]

[ "Handle", "a", "special", "case", "when", "computing", "the", "offset", "of", "an", "argument", "from", "the", "frame", "pointer", "." ]

[ "arm", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "0", "1", "1", "1", "1", "0", "0", "\"unable to compute real location of stacked parameter\"", "8" ]

[]

[ "<s>", "bool", "useAA", "(", ")", "const", "override", "{", "return", "UseAA", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "X86" ]

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "MCS51" ]

[]

[ "<s>", "void", "replaceSuccessorWith", "(", "TerminatorInst", "*", "Terminator", ",", "BasicBlock", "*", "OriginalBB", ",", "BasicBlock", "*", "NewBB", ")", "{", "assert", "(", "Terminator", "&&", "OriginalBB", "&&", "NewBB", ")", ";", "if", "(", "auto", "*", "Branch", "=", "dyn_cast", "<", "BranchInst", ">", "(", "Terminator", ")", ")", "{", "if", "(", "Branch", "->", "getSuccessor", "(", "0", ")", "==", "OriginalBB", ")", "{", "Branch", "->", "setSuccessor", "(", "0", ",", "NewBB", ")", ";", "return", ";", "}", "assert", "(", "Branch", "->", "isConditional", "(", ")", "&&", "\"OriginalBB missing\"", ")", ";", "assert", "(", "Branch", "->", "getSuccessor", "(", "1", ")", "==", "OriginalBB", "&&", "\"OriginalBB is missing\"", ")", ";", "Branch", "->", "setSuccessor", "(", "1", ",", "NewBB", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Not implemented\"", ")", ";", "}", "</s>" ]

[ "Replace", "specified", "successor", "OldBB", "to", "point", "at", "the", "provided", "block", "." ]

[ "TVM", "0", "0", "\"OriginalBB missing\"", "1", "\"OriginalBB is missing\"", "1", "\"Not implemented\"" ]

[]

[ "<s>", "static", "rtx", "nios2_expand_custom_builtin", "(", "tree", "exp", ",", "unsigned", "int", "index", ",", "rtx", "target", ")", "{", "bool", "has_target_p", "=", "(", "TREE_TYPE", "(", "exp", ")", "!=", "void_type_node", ")", ";", "machine_mode", "tmode", "=", "VOIDmode", ";", "int", "nargs", ",", "argno", ";", "rtx", "value", ",", "insn", ",", "unspec_args", "[", "3", "]", ";", "tree", "arg", ";", "if", "(", "has_target_p", ")", "{", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "REG_P", "(", "target", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "nargs", "=", "call_expr_nargs", "(", "exp", ")", ";", "for", "(", "argno", "=", "0", ";", "argno", "<", "nargs", ";", "argno", "++", ")", "{", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "argno", ")", ";", "value", "=", "expand_normal", "(", "arg", ")", ";", "unspec_args", "[", "argno", "]", "=", "value", ";", "if", "(", "argno", "==", "0", ")", "{", "if", "(", "!", "custom_insn_opcode", "(", "value", ",", "VOIDmode", ")", ")", "error", "(", "\"custom instruction opcode must be a compile-time \"", "\"constant in the range 0-255 for %<__builtin_custom_%s%>\"", ",", "custom_builtin_name", "[", "index", "]", ")", ";", "}", "else", "unspec_args", "[", "argno", "]", "=", "force_reg", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg", ")", ")", ",", "unspec_args", "[", "argno", "]", ")", ";", "}", "for", "(", ";", "argno", "<", "3", ";", "argno", "++", ")", "unspec_args", "[", "argno", "]", "=", "const0_rtx", ";", "insn", "=", "(", "has_target_p", "?", "gen_rtx_SET", "(", "target", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "tmode", ",", "gen_rtvec_v", "(", "3", ",", "unspec_args", ")", ",", "UNSPECV_CUSTOM_XNXX", ")", ")", ":", "gen_rtx_UNSPEC_VOLATILE", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "3", ",", "unspec_args", ")", ",", "UNSPECV_CUSTOM_NXX", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "has_target_p", "?", "target", ":", "const0_rtx", ";", "}", "</s>" ]

[ "Helper", "function", "for", "expanding", "custom", "builtins", "." ]

[ "nios2", "3", "0", "0", "\"custom instruction opcode must be a compile-time \"", "\"constant in the range 0-255 for %<__builtin_custom_%s%>\"", "3", "3", "3" ]

[]

[ "<s>", "bool", "A15SDOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "STI", "=", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "(", "STI", ".", "isCortexA15", "(", ")", "&&", "STI", ".", "hasNEON", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running on function \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DeadInstr", ".", "clear", "(", ")", ";", "Replacements", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "Modified", "|=", "runOnInstruction", "(", "&", "MI", ")", ";", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "DeadInstr", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "ARM", "ARM", "ARM", "\"Running on function \"", "\"\\n\"" ]

[]

[ "<s>", "static", "rtx", "spu_addr_space_convert", "(", "rtx", "op", ",", "tree", "from_type", ",", "tree", "to_type", ")", "{", "addr_space_t", "from_as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "from_type", ")", ")", ";", "addr_space_t", "to_as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "to_type", ")", ")", ";", "gcc_assert", "(", "from_as", "==", "ADDR_SPACE_GENERIC", "||", "from_as", "==", "ADDR_SPACE_EA", ")", ";", "gcc_assert", "(", "to_as", "==", "ADDR_SPACE_GENERIC", "||", "to_as", "==", "ADDR_SPACE_EA", ")", ";", "if", "(", "to_as", "==", "ADDR_SPACE_GENERIC", "&&", "from_as", "==", "ADDR_SPACE_EA", ")", "{", "rtx", "result", ",", "ls", ";", "ls", "=", "gen_const_mem", "(", "DImode", ",", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__ea_local_store\"", ")", ")", ";", "set_mem_align", "(", "ls", ",", "128", ")", ";", "result", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "ls", "=", "force_reg", "(", "Pmode", ",", "convert_modes", "(", "Pmode", ",", "DImode", ",", "ls", ",", "1", ")", ")", ";", "op", "=", "force_reg", "(", "Pmode", ",", "convert_modes", "(", "Pmode", ",", "EAmode", ",", "op", ",", "1", ")", ")", ";", "ls", "=", "emit_conditional_move", "(", "ls", ",", "NE", ",", "op", ",", "const0_rtx", ",", "Pmode", ",", "ls", ",", "const0_rtx", ",", "Pmode", ",", "1", ")", ";", "emit_insn", "(", "gen_subsi3", "(", "result", ",", "op", ",", "ls", ")", ")", ";", "return", "result", ";", "}", "else", "if", "(", "to_as", "==", "ADDR_SPACE_EA", "&&", "from_as", "==", "ADDR_SPACE_GENERIC", ")", "{", "rtx", "result", ",", "ls", ";", "ls", "=", "gen_const_mem", "(", "DImode", ",", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__ea_local_store\"", ")", ")", ";", "set_mem_align", "(", "ls", ",", "128", ")", ";", "result", "=", "gen_reg_rtx", "(", "EAmode", ")", ";", "ls", "=", "force_reg", "(", "EAmode", ",", "convert_modes", "(", "EAmode", ",", "DImode", ",", "ls", ",", "1", ")", ")", ";", "op", "=", "force_reg", "(", "Pmode", ",", "op", ")", ";", "ls", "=", "emit_conditional_move", "(", "ls", ",", "NE", ",", "op", ",", "const0_rtx", ",", "Pmode", ",", "ls", ",", "const0_rtx", ",", "EAmode", ",", "1", ")", ";", "op", "=", "force_reg", "(", "EAmode", ",", "convert_modes", "(", "EAmode", ",", "Pmode", ",", "op", ",", "1", ")", ")", ";", "if", "(", "EAmode", "==", "SImode", ")", "emit_insn", "(", "gen_addsi3", "(", "result", ",", "op", ",", "ls", ")", ")", ";", "else", "emit_insn", "(", "gen_adddi3", "(", "result", ",", "op", ",", "ls", ")", ")", ";", "return", "result", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Convert", "from", "one", "address", "space", "to", "another", "." ]

[ "spu", "\"__ea_local_store\"", "128", "1", "1", "1", "\"__ea_local_store\"", "128", "1", "1", "1" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "case", "Match_Success", ":", "ProcessInstruction", "(", "Inst", ",", "Operands", ")", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "PPCOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "PowerPC", "PPC", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0ULL", "\"too few operands for instruction\"", "PPC", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "const", "OR1KRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "Known", ".", "resetAll", "(", ")", ";", "KnownBits", "Known2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "{", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "31", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_U32", ")", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "32", "-", "Width", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "FP_TO_FP16", ":", "case", "AMDGPUISD", "::", "FP16_ZEXT", ":", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "16", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "32", "31", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "0x1f", "AMDGPUISD::BFE_U32", "32", "32", "AMDGPUISD::FP_TO_FP16", "AMDGPUISD::FP16_ZEXT", "16" ]

[]

[ "<s>", "static", "rtx", "sh_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "if", "(", "flag_pic", ")", "x", "=", "legitimize_pic_address", "(", "oldx", ",", "mode", ",", "NULL_RTX", ")", ";", "if", "(", "(", "TARGET_FPU_DOUBLE", "&&", "mode", "==", "DFmode", ")", "||", "(", "TARGET_SH2E", "&&", "mode", "==", "SFmode", ")", ")", "return", "x", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "BASE_REGISTER_RTX_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "struct", "disp_adjust", "adj", "=", "sh_find_mov_disp_adjust", "(", "mode", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "adj", ".", "offset_adjust", "!=", "NULL_RTX", "&&", "adj", ".", "mov_disp", "!=", "NULL_RTX", ")", "{", "rtx", "sum", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "XEXP", "(", "x", ",", "0", ")", ",", "adj", ".", "offset_adjust", ",", "NULL_RTX", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "sum", ",", "adj", ".", "mov_disp", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Try", "to", "modify", "an", "illegitimate", "address", "and", "make", "it", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "Otherwise", ",", "return", "the", "original", "address", "." ]

[ "sh", "1", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "inline", "void", "aarch64_add_sp", "(", "int", "scratchreg", ",", "HOST_WIDE_INT", "delta", ",", "bool", "emit_move_imm", ")", "{", "aarch64_add_constant_internal", "(", "Pmode", ",", "SP_REGNUM", ",", "scratchreg", ",", "delta", ",", "true", ",", "emit_move_imm", ")", ";", "}", "</s>" ]

[ "Add", "DELTA", "to", "the", "stack", "pointer", ",", "marking", "the", "instructions", "frame-related", ".", "TEMP1", "is", "available", "as", "a", "temporary", "if", "nonnull", ".", "EMIT_MOVE_IMM", "is", "false", "if", "TEMP1", "already", "contains", "abs", "(", "DELTA", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "char", "*", "detect_caches_aix", "(", "void", ")", "{", "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "l1_sizekb", "=", "_system_configuration", ".", "dcache_size", "/", "1024", ";", "l1_line", "=", "_system_configuration", ".", "dcache_line", ";", "l1_assoc", "=", "_system_configuration", ".", "dcache_asc", ";", "l2_sizekb", "=", "_system_configuration", ".", "L2_cache_size", "/", "1024", ";", "return", "describe_cache", "(", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ")", ";", "}", "</s>" ]

[ "Returns", "the", "description", "of", "caches", "on", "AIX", "." ]

[ "powerpcspe", "1024", "1024" ]

[]

[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "PowerPC" ]

[]

[ "<s>", "rtx", "extract_movd44_odd_reg", "(", "rtx_insn", "*", "insn", ")", "{", "gcc_assert", "(", "movd44_insn_p", "(", "insn", ")", ")", ";", "rtx", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "machine_mode", "mode", ";", "gcc_assert", "(", "REG_P", "(", "def_reg", ")", "||", "GET_CODE", "(", "def_reg", ")", "==", "SUBREG", ")", ";", "switch", "(", "GET_MODE", "(", "def_reg", ")", ")", "{", "case", "E_DImode", ":", "mode", "=", "SImode", ";", "break", ";", "case", "E_DFmode", ":", "mode", "=", "SFmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_highpart", "(", "mode", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Extract", "the", "second", "result", "(", "odd", "reg", ")", "of", "a", "movd44", "insn", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "HasDebugInfo", "=", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ";", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "delete", "[", "]", "gv_array", ";", "if", "(", "HasDebugInfo", ")", "OutStreamer", "->", "EmitRawText", "(", "\"//\\t}\"", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "NVPTX", "NVPTX", "0", "0", "\"//\\t}\"" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v32i8", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::v32i1", "MVT::v32i8" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Sparc", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_sparc_call30\"", ",", "2", ",", "30", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_br22\"", ",", "10", ",", "22", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_br19\"", ",", "13", ",", "19", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_br16_2\"", ",", "10", ",", "2", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_br16_14\"", ",", "18", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_hi22\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_lo10\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_h44\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_m44\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_l44\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_sparc_hh\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_hm\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_pc22\"", ",", "10", ",", "22", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_pc10\"", ",", "22", ",", "10", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_got22\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_got10\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_wplt30\"", ",", "2", ",", "30", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_sparc_tls_gd_hi22\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_gd_lo10\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_gd_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_gd_call\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldm_hi22\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldm_lo10\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldm_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldm_call\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldo_hix22\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldo_lox10\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ldo_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ie_hi22\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ie_lo10\"", ",", "22", ",", "10", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ie_ld\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ie_ldx\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_ie_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_le_hix22\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_sparc_tls_le_lox10\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "Sparc", "Sparc::NumTargetFixupKinds", "\"fixup_sparc_call30\"", "2", "30", "\"fixup_sparc_br22\"", "10", "22", "\"fixup_sparc_br19\"", "13", "19", "\"fixup_sparc_br16_2\"", "10", "2", "\"fixup_sparc_br16_14\"", "18", "14", "\"fixup_sparc_hi22\"", "10", "22", "0", "\"fixup_sparc_lo10\"", "22", "10", "0", "\"fixup_sparc_h44\"", "10", "22", "0", "\"fixup_sparc_m44\"", "22", "10", "0", "\"fixup_sparc_l44\"", "20", "12", "0", "\"fixup_sparc_hh\"", "10", "22", "0", "\"fixup_sparc_hm\"", "22", "10", "0", "\"fixup_sparc_pc22\"", "10", "22", "\"fixup_sparc_pc10\"", "22", "10", "\"fixup_sparc_got22\"", "10", "22", "0", "\"fixup_sparc_got10\"", "22", "10", "0", "\"fixup_sparc_wplt30\"", "2", "30", "\"fixup_sparc_tls_gd_hi22\"", "10", "22", "0", "\"fixup_sparc_tls_gd_lo10\"", "22", "10", "0", "\"fixup_sparc_tls_gd_add\"", "0", "0", "0", "\"fixup_sparc_tls_gd_call\"", "0", "0", "0", "\"fixup_sparc_tls_ldm_hi22\"", "10", "22", "0", "\"fixup_sparc_tls_ldm_lo10\"", "22", "10", "0", "\"fixup_sparc_tls_ldm_add\"", "0", "0", "0", "\"fixup_sparc_tls_ldm_call\"", "0", "0", "0", "\"fixup_sparc_tls_ldo_hix22\"", "10", "22", "0", "\"fixup_sparc_tls_ldo_lox10\"", "22", "10", "0", "\"fixup_sparc_tls_ldo_add\"", "0", "0", "0", "\"fixup_sparc_tls_ie_hi22\"", "10", "22", "0", "\"fixup_sparc_tls_ie_lo10\"", "22", "10", "0", "\"fixup_sparc_tls_ie_ld\"", "0", "0", "0", "\"fixup_sparc_tls_ie_ldx\"", "0", "0", "0", "\"fixup_sparc_tls_ie_add\"", "0", "0", "0", "\"fixup_sparc_tls_le_hix22\"", "0", "0", "0", "\"fixup_sparc_tls_le_lox10\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "int", "arm_issue_rate", "(", "void", ")", "{", "switch", "(", "arm_tune", ")", "{", "case", "xgene1", ":", "return", "4", ";", "case", "cortexa15", ":", "case", "cortexa57", ":", "case", "exynosm1", ":", "return", "3", ";", "case", "cortexm7", ":", "case", "cortexr4", ":", "case", "cortexr4f", ":", "case", "cortexr5", ":", "case", "genericv7a", ":", "case", "cortexa5", ":", "case", "cortexa7", ":", "case", "cortexa8", ":", "case", "cortexa9", ":", "case", "cortexa12", ":", "case", "cortexa17", ":", "case", "cortexa53", ":", "case", "fa726te", ":", "case", "marvell_pj4", ":", "return", "2", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Most", "ARM", "cores", "are", "single", "issue", ",", "but", "some", "newer", "ones", "can", "dual", "issue", ".", "The", "scheduler", "descriptions", "rely", "on", "this", "being", "correct", "." ]

[ "arm", "4", "3", "2", "1" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STri", "||", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STXri", "||", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STFri", "||", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STDFri", "||", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STQFri", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Sparc", "Sparc", "SP::STri", "SP::STXri", "SP::STFri", "SP::STDFri", "SP::STQFri", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "ARM", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_arm_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_thumb_adr_pcrel_10\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_condbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_uncondbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_condbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_uncondbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_br\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bl\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_blx\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cb\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cp\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bcc\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "ARM", "ARM::NumTargetFixupKinds", "\"fixup_arm_ldst_pcrel_12\"", "0", "32", "\"fixup_t2_ldst_pcrel_12\"", "0", "32", "\"fixup_arm_pcrel_10\"", "0", "32", "\"fixup_t2_pcrel_10\"", "0", "32", "\"fixup_thumb_adr_pcrel_10\"", "0", "8", "\"fixup_arm_adr_pcrel_12\"", "0", "32", "\"fixup_t2_adr_pcrel_12\"", "0", "32", "\"fixup_arm_condbranch\"", "0", "24", "\"fixup_arm_uncondbranch\"", "0", "24", "\"fixup_t2_condbranch\"", "0", "32", "\"fixup_t2_uncondbranch\"", "0", "32", "\"fixup_arm_thumb_br\"", "0", "16", "\"fixup_arm_thumb_bl\"", "0", "32", "\"fixup_arm_thumb_blx\"", "0", "32", "\"fixup_arm_thumb_cb\"", "0", "16", "\"fixup_arm_thumb_cp\"", "0", "8", "\"fixup_arm_thumb_bcc\"", "0", "8", "\"fixup_arm_movt_hi16\"", "0", "20", "0", "\"fixup_arm_movw_lo16\"", "0", "20", "0", "\"fixup_t2_movt_hi16\"", "0", "20", "0", "\"fixup_t2_movw_lo16\"", "0", "20", "0", "\"fixup_arm_movt_hi16_pcrel\"", "0", "20", "\"fixup_arm_movw_lo16_pcrel\"", "0", "20", "\"fixup_t2_movt_hi16_pcrel\"", "0", "20", "\"fixup_t2_movw_lo16_pcrel\"", "0", "20", "\"Invalid kind!\"" ]

[]

[ "<s>", "unsigned", "R600MCCodeEmitter", "::", "getHWRegChan", "(", "unsigned", "reg", ")", "const", "{", "return", "MRI", ".", "getEncodingValue", "(", "reg", ")", ">>", "HW_CHAN_SHIFT", ";", "}", "</s>" ]

[ "get", "the", "HW", "encoding", "for", "a", "register", "'s", "channel", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "gcn_goacc_reduction_init", "(", "gcall", "*", "call", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "enum", "tree_code", "rcode", "=", "(", "enum", "tree_code", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "4", ")", ")", ";", "tree", "init", "=", "omp_reduction_init_op", "(", "gimple_location", "(", "call", ")", ",", "rcode", ",", "TREE_TYPE", "(", "var", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_GANG", ")", "{", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "integer_zerop", "(", "ref_to_res", ")", ")", "init", "=", "var", ";", "}", "if", "(", "lhs", ")", "gimplify_assign", "(", "lhs", ",", "init", ",", "&", "seq", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "Expand", "IFN_GOACC_REDUCTION_INIT", "." ]

[ "gcn", "2", "3", "4", "1" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "while", "(", "isPredicated", "(", "*", "I", ")", "||", "I", "->", "isTerminator", "(", ")", "||", "I", "->", "isDebugValue", "(", ")", ")", "{", "bool", "CantAnalyze", "=", "false", ";", "while", "(", "I", "->", "isDebugInstr", "(", ")", "||", "!", "I", "->", "isTerminator", "(", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "\"FBB should have been null.\"", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "2", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "!", "isPredicated", "(", "*", "I", ")", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "!", "isPredicated", "(", "*", "I", ")", "&&", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "isReturn", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineInstr", "&", "InstToDelete", "=", "*", "DI", ";", "++", "DI", ";", "InstToDelete", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "return", "true", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"FBB should have been null.\"", "0", "1", "2" ]

[]

[ "<s>", "static", "rtx", "riscv_split_integer", "(", "HOST_WIDE_INT", "val", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "loval", "=", "sext_hwi", "(", "val", ",", "32", ")", ";", "unsigned", "HOST_WIDE_INT", "hival", "=", "sext_hwi", "(", "(", "val", "-", "loval", ")", ">>", "32", ",", "32", ")", ";", "rtx", "hi", "=", "gen_reg_rtx", "(", "mode", ")", ",", "lo", "=", "gen_reg_rtx", "(", "mode", ")", ";", "riscv_move_integer", "(", "hi", ",", "hi", ",", "hival", ")", ";", "riscv_move_integer", "(", "lo", ",", "lo", ",", "loval", ")", ";", "hi", "=", "gen_rtx_fmt_ee", "(", "ASHIFT", ",", "mode", ",", "hi", ",", "GEN_INT", "(", "32", ")", ")", ";", "hi", "=", "force_reg", "(", "mode", ",", "hi", ")", ";", "return", "gen_rtx_fmt_ee", "(", "PLUS", ",", "mode", ",", "hi", ",", "lo", ")", ";", "}", "</s>" ]

[ "Try", "to", "split", "a", "64b", "integer", "into", "32b", "parts", ",", "then", "reassemble", "." ]

[ "riscv", "32", "32", "32", "32" ]

[]

[ "<s>", "bool", "WDC65816PassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "WDC65816", "WDC" ]

[]

[ "<s>", "bool", "M68kAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MMFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "MCInstLowering", "=", "std", "::", "make_unique", "<", "M68kMCInstLower", ">", "(", "MF", ",", "*", "this", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "M68k", "M68k", "M68k", "M68k" ]

[]

[ "<s>", "static", "int", "loongarch_fp_mult_cost", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "DFmode", "?", "loongarch_cost", "->", "fp_mult_df", ":", "loongarch_cost", "->", "fp_mult_sf", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "floating-point", "multiplications", "of", "mode", "MODE", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "const", "char", "*", "get_trap_mode_suffix", "(", "void", ")", "{", "enum", "attr_trap_suffix", "s", "=", "get_attr_trap_suffix", "(", "current_output_insn", ")", ";", "switch", "(", "s", ")", "{", "case", "TRAP_SUFFIX_NONE", ":", "return", "NULL", ";", "case", "TRAP_SUFFIX_SU", ":", "if", "(", "alpha_fptm", ">=", "ALPHA_FPTM_SU", ")", "return", "\"su\"", ";", "return", "NULL", ";", "case", "TRAP_SUFFIX_SUI", ":", "if", "(", "alpha_fptm", ">=", "ALPHA_FPTM_SUI", ")", "return", "\"sui\"", ";", "return", "NULL", ";", "case", "TRAP_SUFFIX_V_SV", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"v\"", ";", "case", "ALPHA_FPTM_SU", ":", "case", "ALPHA_FPTM_SUI", ":", "return", "\"sv\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "TRAP_SUFFIX_V_SV_SVI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"v\"", ";", "case", "ALPHA_FPTM_SU", ":", "return", "\"sv\"", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "\"svi\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "TRAP_SUFFIX_U_SU_SUI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"u\"", ";", "case", "ALPHA_FPTM_SU", ":", "return", "\"su\"", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "\"sui\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "trap", "mode", "suffix", "applicable", "to", "the", "current", "instruction", ",", "or", "NULL", "." ]

[ "alpha", "\"su\"", "\"sui\"", "\"v\"", "\"sv\"", "\"v\"", "\"sv\"", "\"svi\"", "\"u\"", "\"su\"", "\"sui\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_sve_tbl", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "HOST_WIDE_INT", "nelt", ";", "if", "(", "!", "d", "->", "one_vector_p", "&&", "!", "d", "->", "perm", ".", "length", "(", ")", ".", "is_constant", "(", "&", "nelt", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "machine_mode", "sel_mode", "=", "related_int_vector_mode", "(", "d", "->", "vmode", ")", ".", "require", "(", ")", ";", "rtx", "sel", "=", "vec_perm_indices_to_rtx", "(", "sel_mode", ",", "d", "->", "perm", ")", ";", "if", "(", "d", "->", "one_vector_p", ")", "emit_unspec2", "(", "d", "->", "target", ",", "UNSPEC_TBL", ",", "d", "->", "op0", ",", "force_reg", "(", "sel_mode", ",", "sel", ")", ")", ";", "else", "aarch64_expand_sve_vec_perm", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "sel", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "implement", "D", "using", "an", "SVE", "TBL", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "PIC16InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "PIC16TargetLowering", "*", "PTLI", "=", "TM", ".", "getTargetLowering", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getTempdataLabel", "(", "FuncName", ")", ")", ";", "if", "(", "RC", "==", "PIC16", "::", "GPRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PIC16", "::", "movwf", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "1", ",", "*", "MBB", ".", "getParent", "(", ")", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "if", "(", "RC", "==", "PIC16", "::", "FSR16RegisterClass", ")", "{", "unsigned", "opcode", "=", "(", "SrcReg", "==", "PIC16", "::", "FSR0", ")", "?", "PIC16", "::", "save_fsr0", ":", "PIC16", "::", "save_fsr1", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "3", ",", "*", "MBB", ".", "getParent", "(", ")", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "PIC16", "PIC16", "PIC16", "PIC16::GPRRegisterClass", "PIC16::movwf", "1", "1", "PIC16::FSR16RegisterClass", "PIC16::FSR0", "PIC16::save_fsr0", "PIC16::save_fsr1", "3", "1", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "bool", "fa726te_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep", ",", "int", "*", "cost", ")", "{", "if", "(", "dep_type", "==", "REG_DEP_TRUE", "&&", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "recog_memoized", "(", "dep", ")", ">=", "0", "&&", "get_attr_conds", "(", "dep", ")", "==", "CONDS_SET", ")", "{", "if", "(", "get_attr_conds", "(", "insn", ")", "==", "CONDS_USE", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_BRANCH", ")", "{", "*", "cost", "=", "3", ";", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", "||", "get_attr_conds", "(", "insn", ")", "==", "CONDS_USE", ")", "{", "*", "cost", "=", "0", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Adjust", "cost", "hook", "for", "FA726TE", "." ]

[ "arm", "0", "0", "3", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "COREV_EXPAND_HWLP_PSEUDO_NAME", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "RISCV" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isCtlzFast", "(", ")", "const", "{", "return", "Subtarget", ".", "hasFastLZCNT", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "ctlz", "instruction", "is", "fast", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "\"Shrink-wrapping not yet supported\"", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "static", "machine_mode", "counter_mode", "(", "rtx", "count_exp", ")", "{", "if", "(", "GET_MODE", "(", "count_exp", ")", "!=", "VOIDmode", ")", "return", "GET_MODE", "(", "count_exp", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "count_exp", ")", ")", "return", "Pmode", ";", "if", "(", "TARGET_64BIT", "&&", "(", "INTVAL", "(", "count_exp", ")", "&", "~", "0xffffffff", ")", ")", "return", "DImode", ";", "return", "SImode", ";", "}", "</s>" ]

[ "Return", "mode", "for", "the", "memcpy/memset", "loop", "counter", ".", "Prefer", "SImode", "over", "DImode", "for", "constant", "loop", "counts", "." ]

[ "i386", "0xffffffff" ]

[]

[ "<s>", "bool", "ix86_hardreg_mov_ok", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "if", "(", "REG_P", "(", "dst", ")", "&&", "HARD_REGISTER_P", "(", "dst", ")", "&&", "!", "REG_P", "(", "src", ")", "&&", "!", "MEM_P", "(", "src", ")", "&&", "!", "(", "VECTOR_MODE_P", "(", "GET_MODE", "(", "dst", ")", ")", "?", "standard_sse_constant_p", "(", "src", ",", "GET_MODE", "(", "dst", ")", ")", ":", "x86_64_immediate_operand", "(", "src", ",", "GET_MODE", "(", "dst", ")", ")", ")", "&&", "ix86_class_likely_spilled_p", "(", "REGNO_REG_CLASS", "(", "REGNO", "(", "dst", ")", ")", ")", "&&", "!", "reload_completed", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "set", "of", "DST", "by", "the", "expression", "SRC", "should", "be", "allowed", ".", "This", "prevents", "complex", "sets", "of", "likely_spilled", "hard", "regs", "before", "reload", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"" ]

[]

[ "<s>", "bool", "LinearizedRegion", "::", "isLiveOut", "(", "unsigned", "Reg", ")", "{", "return", "LiveOuts", ".", "contains", "(", "Reg", ")", ";", "}", "</s>" ]

[ "isLiveOut", "-", "Determine", "if", "Reg", "is", "live", "out", "from", "MBB", ",", "when", "not", "considering", "PHI", "nodes", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "getFramePointerReg", "(", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "void", "apply", "(", "ScheduleDAGInstrs", "*", "DAGInstrs", ")", "override", "{", "const", "GCNSubtarget", "&", "ST", "=", "DAGInstrs", "->", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasMAIInsts", "(", ")", "||", "DisablePowerSched", ")", "return", ";", "DAG", "=", "static_cast", "<", "ScheduleDAGMI", "*", ">", "(", "DAGInstrs", ")", ";", "const", "TargetSchedModel", "*", "TSchedModel", "=", "DAGInstrs", "->", "getSchedModel", "(", ")", ";", "if", "(", "!", "TSchedModel", "||", "DAG", "->", "SUnits", ".", "empty", "(", ")", ")", "return", ";", "auto", "LastSALU", "=", "DAG", "->", "SUnits", ".", "begin", "(", ")", ";", "auto", "E", "=", "DAG", "->", "SUnits", ".", "end", "(", ")", ";", "SmallPtrSet", "<", "SUnit", "*", ",", "32", ">", "Visited", ";", "for", "(", "SUnit", "&", "SU", ":", "DAG", "->", "SUnits", ")", "{", "MachineInstr", "&", "MAI", "=", "*", "SU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "TII", "->", "isMAI", "(", "MAI", ")", "||", "MAI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32", "||", "MAI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_ACCVGPR_READ_B32", ")", "continue", ";", "unsigned", "Lat", "=", "TSchedModel", "->", "computeInstrLatency", "(", "&", "MAI", ")", "-", "1", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found MFMA: \"", ";", "DAG", "->", "dumpNode", "(", "SU", ")", ";", "dbgs", "(", ")", "<<", "\"Need \"", "<<", "Lat", "<<", "\" instructions to cover latency.\\n\"", ")", ";", "for", "(", ";", "Lat", "&&", "LastSALU", "!=", "E", ";", "++", "LastSALU", ")", "{", "if", "(", "Visited", ".", "count", "(", "&", "*", "LastSALU", ")", ")", "continue", ";", "if", "(", "!", "isSALU", "(", "&", "*", "LastSALU", ")", "||", "!", "canAddEdge", "(", "&", "*", "LastSALU", ",", "&", "SU", ")", ")", "continue", ";", "Lat", "-=", "linkSALUChain", "(", "&", "SU", ",", "&", "*", "LastSALU", ",", "Lat", ",", "Visited", ")", ";", "}", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AMDGPU", "32", "AMDGPU::V_ACCVGPR_WRITE_B32", "AMDGPU::V_ACCVGPR_READ_B32", "1", "\"Found MFMA: \"", "\"Need \"", "\" instructions to cover latency.\\n\"" ]

[]

[ "<s>", "const", "char", "*", "MandarinTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "MDISD", "::", "RET_FLAG", ":", "return", "\"MDISD::RET_FLAG\"", ";", "case", "MDISD", "::", "CMP", ":", "return", "\"MDISD::CMP\"", ";", "case", "MDISD", "::", "ICMP", ":", "return", "\"MDISD::ICMP\"", ";", "case", "MDISD", "::", "FCMP", ":", "return", "\"MDISD::FCMP\"", ";", "case", "MDISD", "::", "BR_CC", ":", "return", "\"MDISD::BR_CC\"", ";", "case", "MDISD", "::", "SELECT_CC", ":", "return", "\"MDISD::SELECT_CC\"", ";", "case", "MDISD", "::", "HIGH", ":", "return", "\"MDISD::HIGH\"", ";", "case", "MDISD", "::", "LOW", ":", "return", "\"MDISD::LOW\"", ";", "case", "MDISD", "::", "CALL", ":", "return", "\"MDISD::CALL\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Mandarin", "0", "MDISD::RET_FLAG", "\"MDISD::RET_FLAG\"", "MDISD::CMP", "\"MDISD::CMP\"", "MDISD::ICMP", "\"MDISD::ICMP\"", "MDISD::FCMP", "\"MDISD::FCMP\"", "MDISD::BR_CC", "\"MDISD::BR_CC\"", "MDISD::SELECT_CC", "\"MDISD::SELECT_CC\"", "MDISD::HIGH", "\"MDISD::HIGH\"", "MDISD::LOW", "\"MDISD::LOW\"", "MDISD::CALL", "\"MDISD::CALL\"" ]

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "SUnit", "*", "SU", ";", "if", "(", "llvm", "::", "ForceTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ".", "Available", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "TopResult", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "llvm", "::", "ForceBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ".", "Available", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "BotResult", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidrectional", "(", "IsTopNode", ")", ";", "}", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "(", "IsTopNode", "?", "\"Top\"", ":", "\"Bottom\"", ")", "<<", "\" Scheduling Instruction in cycle \"", "<<", "(", "IsTopNode", "?", "Top", ".", "CurrCycle", ":", "Bot", ".", "CurrCycle", ")", "<<", "'\\n'", ";", "SU", "->", "dump", "(", "DAG", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "Hexagon", "\"ReadyQ garbage\"", "\"failed to find the first candidate\"", "\"failed to find the first candidate\"", "\"*** \"", "\"Top\"", "\"Bottom\"", "\" Scheduling Instruction in cycle \"" ]

[]

[ "<s>", "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", "(", ")", "==", "R600", "::", "JUMP", ")", "{", "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", "==", "R600", "::", "JUMP", ")", "{", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "if", "(", "LastOpc", "==", "R600", "::", "JUMP_COND", ")", "{", "auto", "predSet", "=", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "R600", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "&", "SecondLastInst", "=", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "SecondLastOpc", "==", "R600", "::", "JUMP_COND", "&&", "LastOpc", "==", "R600", "::", "JUMP", ")", "{", "auto", "predSet", "=", "--", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "FBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "R600", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600::JUMP", "R600::JUMP", "0", "R600::JUMP_COND", "0", "1", "2", "R600::PRED_SEL_ONE", "R600::JUMP_COND", "R600::JUMP", "0", "0", "1", "2", "R600::PRED_SEL_ONE" ]

[]

[ "<s>", "Liveness", "(", "MachineRegisterInfo", "&", "mri", ",", "const", "DataFlowGraph", "&", "g", ")", ":", "DFG", "(", "g", ")", ",", "TRI", "(", "g", ".", "getTRI", "(", ")", ")", ",", "MDT", "(", "g", ".", "getDT", "(", ")", ")", ",", "MDF", "(", "g", ".", "getDF", "(", ")", ")", ",", "RAI", "(", "g", ".", "getRAI", "(", ")", ")", ",", "MRI", "(", "mri", ")", ",", "Empty", "(", ")", ",", "Trace", "(", "false", ")", "{", "}", "</s>" ]

[ "During", "our", "initial", "pass", "over", "the", "program", ",", "we", "determine", "that", "things", "are", "either", "alive", "or", "maybe", "alive", ".", "More", "..." ]

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "PIC16RegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "assert", "(", "0", "&&", "\"PIC16 Does not have any return address register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "PIC16", "PIC16", "0", "\"PIC16 Does not have any return address register\"", "0" ]

[]

[ "<s>", "bool", "SICAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SICFI", "=", "MF", ".", "getInfo", "<", "SICFunctionInfo", ">", "(", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "SIC", "SIC", "SIC", "SIC" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "Cpu0TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "Info", ",", "const", "char", "*", "Constraint", ")", "const", "{", "ConstraintWeight", "Weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "Info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "T", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "Constraint", ")", "{", "default", ":", "Weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "Info", ",", "Constraint", ")", ";", "break", ";", "case", "'c'", ":", "if", "(", "T", "->", "isIntegerTy", "(", ")", ")", "Weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "Weight", "=", "CW_Constant", ";", "break", ";", "case", "'R'", ":", "Weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "Weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "SDValue", "ARCompactTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_ARCompact32", ")", ";", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "int", "RetAddrOffset", "=", "8", ";", "SDValue", "RetAddrOffsetNode", "=", "DAG", ".", "getConstant", "(", "RetAddrOffset", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "return", "DAG", ".", "getNode", "(", "ARCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetAddrOffsetNode", ",", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ARCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetAddrOffsetNode", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "ARCompact", "ARC", "ISD::OutputArg", "16", "ARC", "0", "0", "\"Can only return in registers!\"", "1", "8", "MVT::i32", "ARCISD::RET_FLAG", "MVT::Other", "ARCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "int", "mmix_asm_preferred_eh_data_format", "(", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "global", "ATTRIBUTE_UNUSED", ")", "{", "return", "DW_EH_PE_absptr", ";", "}", "</s>" ]

[ "ASM_PREFERRED_EH_DATA_FORMAT", "." ]

[ "mmix" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "WebAssembly", "\"WebAssembly Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "union_defs", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ",", "df_ref", "use", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "link", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_in", "=", "1", ";", "while", "(", "link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_in", "=", "1", ";", "if", "(", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "{", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "gcc_assert", "(", "NONDEBUG_INSN_P", "(", "def_insn", ")", ")", ";", "unionfind_union", "(", "insn_entry", "+", "INSN_UID", "(", "insn", ")", ",", "insn_entry", "+", "INSN_UID", "(", "def_insn", ")", ")", ";", "}", "link", "=", "link", "->", "next", ";", "}", "}", "</s>" ]

[ "Union", "INSN", "with", "all", "insns", "containing", "definitions", "that", "reach", "USE", ".", "Detect", "whether", "USE", "is", "live-in", "to", "the", "current", "function", "." ]

[ "rs6000", "1", "1" ]

[]

[ "<s>", "DecodeStatus", "ARCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "MCDisassembler", "::", "DecodeStatus", "Result", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "Fail", ";", "}", "uint8_t", "DecodeByte", "=", "(", "Bytes", "[", "1", "]", "&", "0xF7", ")", ">>", "3", ";", "if", "(", "DecodeByte", "<", "0x08", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "Fail", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "uint64_t", "Insn64", ";", "if", "(", "!", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn64", ")", ")", "return", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable64", ",", "Instr", ",", "Insn64", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Success", "==", "Result", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Successfully decoded 64-bit instruction.\"", ")", ";", "return", "Result", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Not a 64-bit instruction, falling back to 32-bit.\"", ")", ";", "}", "uint32_t", "Insn32", ";", "if", "(", "!", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn32", ")", ")", "{", "return", "Fail", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "Instr", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "6", ")", "{", "uint64_t", "Insn48", ";", "if", "(", "!", "readInstruction48", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn48", ")", ")", "return", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable48", ",", "Instr", ",", "Insn48", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Success", "==", "Result", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Successfully decoded 16-bit instruction with limm.\"", ")", ";", "return", "Result", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Not a 16-bit instruction with limm, try without it.\"", ")", ";", "}", "uint32_t", "Insn16", ";", "if", "(", "!", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn16", ")", ")", "return", "Fail", ";", "return", "decodeInstruction", "(", "DecoderTable16", ",", "Instr", ",", "Insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "}", "</s>" ]

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

[ "ARC", "ARC", "2", "0", "1", "0xF7", "3", "0x08", "4", "0", "8", "\"Successfully decoded 64-bit instruction.\"", "\"Not a 64-bit instruction, falling back to 32-bit.\"", "6", "\"Successfully decoded 16-bit instruction with limm.\"", "\"Not a 16-bit instruction with limm, try without it.\"" ]

[]

[ "<s>", "const", "char", "*", "output_addsi3", "(", "rtx", "*", "operands", ")", "{", "if", "(", "!", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "!", "ADDRESS_REG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", "=", "operands", "[", "1", "]", ";", "operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "2", "]", "=", "tmp", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "32768", "||", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "32767", ")", ")", "return", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "return", "MOTOROLA", "?", "\"lea (%1,%2.l),%0\"", ":", "\"lea %1@(0,%2:l),%0\"", ";", "return", "MOTOROLA", "?", "\"lea (%c2,%1),%0\"", ":", "\"lea %1@(%c2),%0\"", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "8", ")", "return", "\"addq%.l %2,%0\"", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "8", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "return", "\"subq%.l %2,%0\"", ";", "}", "if", "(", "TUNE_CPU32", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", ";", "}", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", ";", "}", "}", "if", "(", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "0x8000", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0x8000", ")", "{", "if", "(", "TUNE_68040", ")", "return", "\"add%.w %2,%0\"", ";", "else", "return", "MOTOROLA", "?", "\"lea (%c2,%0),%0\"", ":", "\"lea %0@(%c2),%0\"", ";", "}", "}", "return", "\"add%.l %2,%0\"", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "perform", "a", "32", "bit", "3", "operand", "add", "." ]

[ "m68k", "0", "1", "1", "1", "1", "2", "2", "2", "2", "32768", "2", "32767", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", "2", "\"lea (%1,%2.l),%0\"", "\"lea %1@(0,%2:l),%0\"", "\"lea (%c2,%1),%0\"", "\"lea %1@(%c2),%0\"", "2", "2", "0", "2", "8", "\"addq%.l %2,%0\"", "2", "0", "2", "8", "2", "2", "\"subq%.l %2,%0\"", "0", "2", "8", "2", "16", "2", "2", "8", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", "2", "8", "2", "16", "2", "2", "8", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", "0", "2", "0x8000", "2", "0x8000", "\"add%.w %2,%0\"", "\"lea (%c2,%0),%0\"", "\"lea %0@(%c2),%0\"", "\"add%.l %2,%0\"" ]

[]