Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "P2" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "FeatureBitset", "MissingFeatures", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MissingFeatures", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "ensureLocals", "(", "Out", ")", ";", "auto", "Align", "=", "WebAssembly", "::", "GetDefaultP2AlignAny", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Align", "!=", "-", "1U", ")", "{", "auto", "&", "Op0", "=", "Inst", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getImm", "(", ")", "==", "-", "1", ")", "Op0", ".", "setImm", "(", "Align", ")", ";", "}", "if", "(", "is64", ")", "{", "auto", "Opc64", "=", "WebAssembly", "::", "getWasm64Opcode", "(", "static_cast", "<", "uint16_t", ">", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "if", "(", "Opc64", ">=", "0", ")", "{", "Inst", ".", "setOpcode", "(", "Opc64", ")", ";", "}", "}", "if", "(", "!", "SkipTypeCheck", "&&", "TC", ".", "typeCheck", "(", "IDLoc", ",", "Inst", ",", "Operands", ")", ")", "return", "true", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", "IDLoc", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "{", "assert", "(", "MissingFeatures", ".", "count", "(", ")", ">", "0", "&&", "\"Expected missing features\"", ")", ";", "SmallString", "<", "128", ">", "Message", ";", "raw_svector_ostream", "OS", "(", "Message", ")", ";", "OS", "<<", "\"instruction requires:\"", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MissingFeatures", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "MissingFeatures", ".", "test", "(", "i", ")", ")", "OS", "<<", "' '", "<<", "getSubtargetFeatureName", "(", "i", ")", ";", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "Message", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "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", "." ]

[ "WebAssembly", "WebAssembly::GetDefaultP2AlignAny", "1U", "0", "1", "WebAssembly::getWasm64Opcode", "0", "0", "\"Expected missing features\"", "128", "\"instruction requires:\"", "0", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "return", "true", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "O", "<<", "'['", ";", "printOperand", "(", "MI", ",", "OpNum", "+", "1", ",", "O", ")", ";", "O", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "XCore", "XCore", "0", "1" ]

[]

[ "<s>", "bool", "MBlazeTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createMBlazeDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "rtx", "arm_expand_unop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ",", "rtx", "target", ",", "int", "do_load", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "enum", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "enum", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "do_load", ")", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "else", "{", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "}", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Subroutine", "of", "arm_expand_builtin", "to", "take", "care", "of", "unop", "insns", "." ]

[ "arm", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "pop", "(", ")", "{", "Set", ".", "erase", "(", "front", "(", ")", ")", ";", "Uses", ".", "pop", "(", ")", ";", "}", "</s>" ]

[ "Pop", "the", "previous", "solver", "state", "." ]

[ "Hexagon" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "DCPU16TargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "C_RegisterClass", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "Dcpu16", "DCPU16", "1", "0" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "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_Sparc32", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "SDValue", "(", ")", ")", ";", "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", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "RetAddrOffset", "=", "8", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "SparcMachineFunctionInfo", "*", "SFI", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "SFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "SP", "::", "I0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "SP", "::", "I0", ",", "getPointerTy", "(", ")", ")", ")", ";", "RetAddrOffset", "=", "12", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "RetOps", "[", "1", "]", "=", "DAG", ".", "getConstant", "(", "RetAddrOffset", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "ISD::OutputArg", "16", "Sparc", "4", "1", "0", "\"Can only return in registers!\"", "1", "8", "Sparc", "Sparc", "\"sret virtual register not created in the entry block\"", "SP::I0", "1", "SP::I0", "12", "0", "1", "MVT::i32", "SPISD::RET_FLAG", "MVT::Other", "0" ]

[]

[ "<s>", "static", "bool", "avr_reg_ok_for_pgm_addr", "(", "rtx", "reg", ",", "bool", "strict", ")", "{", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "if", "(", "strict", ")", "{", "return", "REGNO", "(", "reg", ")", "==", "REG_Z", ";", "}", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "REGNO", "(", "reg", ")", "<", "REG_Z", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Helper", "for", "following", "function", "." ]

[ "avr" ]

[]

[ "<s>", "sbitmap", "rs6000_get_separate_components", "(", "void", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "WORLD_SAVE_P", "(", "info", ")", ")", "return", "NULL", ";", "gcc_assert", "(", "!", "(", "info", "->", "savres_strategy", "&", "SAVE_MULTIPLE", ")", "&&", "!", "(", "info", "->", "savres_strategy", "&", "REST_MULTIPLE", ")", ")", ";", "cfun", "->", "machine", "->", "n_components", "=", "64", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "cfun", "->", "machine", "->", "n_components", ")", ";", "bitmap_clear", "(", "components", ")", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "int", "fp_reg_size", "=", "8", ";", "if", "(", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_GPRS", ")", ")", "{", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_gp_reg_save", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", "&&", "save_reg_p", "(", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "+=", "reg_size", ";", "}", "}", "if", "(", "frame_pointer_needed", ")", "bitmap_clear_bit", "(", "components", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "||", "(", "flag_pic", "==", "1", "&&", "DEFAULT_ABI", "==", "ABI_V4", ")", "||", "(", "flag_pic", "&&", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", ")", "bitmap_clear_bit", "(", "components", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_FPRS", ")", ")", "{", "int", "offset", "=", "info", "->", "fp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_fp_reg_save", ";", "regno", "<", "64", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", "&&", "save_reg_p", "(", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "+=", "fp_reg_size", ";", "}", "}", "if", "(", "info", "->", "lr_save_p", "&&", "!", "(", "flag_pic", "&&", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_VRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_VRS", ")", ")", "{", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "bitmap_set_bit", "(", "components", ",", "0", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "save_toc_in_prologue", ")", "bitmap_set_bit", "(", "components", ",", "2", ")", ";", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS", "." ]

[ "rs6000", "64", "4", "8", "8", "32", "0x8000", "0x7fff", "1", "64", "0x8000", "0x7fff", "0x8000", "0x7fff", "0", "2" ]

[]

[ "<s>", "static", "bool", "riscv_classify_address", "(", "struct", "riscv_address_info", "*", "info", ",", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "x", ";", "info", "->", "offset", "=", "const0_rtx", ";", "return", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", ";", "case", "PLUS", ":", "if", "(", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "false", ";", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "riscv_valid_offset_p", "(", "info", "->", "offset", ",", "mode", ")", ")", ";", "case", "LO_SUM", ":", "if", "(", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "false", ";", "info", "->", "type", "=", "ADDRESS_LO_SUM", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "info", "->", "symbol_type", "=", "riscv_classify_symbolic_expression", "(", "info", "->", "offset", ")", ";", "return", "(", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "riscv_valid_lo_sum_p", "(", "info", "->", "symbol_type", ",", "mode", ",", "info", "->", "offset", ")", ")", ";", "case", "CONST_INT", ":", "if", "(", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "false", ";", "info", "->", "type", "=", "ADDRESS_CONST_INT", ";", "return", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "address", "for", "machine", "mode", "MODE", ".", "If", "it", "is", ",", "fill", "in", "INFO", "appropriately", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "riscv", "0", "1", "0", "1" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "ReadCycleWide", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"ReadCycleWrite is only to be used on riscv32\"", ")", ";", "return", "emitReadCycleWidePseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "RISCV", "RISCV", "\"Unexpected instr type to insert\"", "RISCV::ReadCycleWide", "\"ReadCycleWrite is only to be used on riscv32\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "Type", "*", "EltTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "M", "->", "getDataLayout", "(", ")", ";", "IntegerType", "*", "IntEltTy", "=", "Builder", ".", "getIntNTy", "(", "DL", ".", "getTypeSizeInBits", "(", "EltTy", ")", ")", ";", "Value", "*", "Trunc", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "IntEltTy", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Trunc", ",", "EltTy", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_ldaxp", "Intrinsic::aarch64_ldxp", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Cannot deal with nonzero SPAdj yet\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "static_cast", "<", "const", "AArch64FrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "bool", "IsCalleeSaveOp", "=", "FrameIndex", ">=", "MinCSFI", "&&", "FrameIndex", "<=", "MaxCSFI", ";", "unsigned", "FrameReg", ";", "int64_t", "Offset", ";", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "SPAdj", ",", "IsCalleeSaveOp", ")", ";", "bool", "HasOffsetOp", "=", "hasFrameOffset", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "HasOffsetOp", ")", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "const", "AArch64InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "int", "MinOffset", ",", "MaxOffset", ",", "OffsetScale", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ADDxxi_lsl0_s", "||", "!", "HasOffsetOp", ")", "{", "MinOffset", "=", "0", ";", "MaxOffset", "=", "0xfff", ";", "OffsetScale", "=", "1", ";", "}", "else", "{", "TII", ".", "getAddressConstraints", "(", "MI", ",", "OffsetScale", ",", "MinOffset", ",", "MaxOffset", ")", ";", "}", "if", "(", "(", "Offset", "%", "OffsetScale", "!=", "0", "||", "Offset", "<", "MinOffset", "||", "Offset", ">", "MaxOffset", ")", "||", "(", "!", "HasOffsetOp", "&&", "Offset", "!=", "0", ")", ")", "{", "unsigned", "BaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "emitRegUpdate", "(", "MBB", ",", "MBBI", ",", "MBBI", "->", "getDebugLoc", "(", ")", ",", "TII", ",", "BaseReg", ",", "FrameReg", ",", "BaseReg", ",", "Offset", ")", ";", "FrameReg", "=", "BaseReg", ";", "Offset", "=", "0", ";", "}", "assert", "(", "Offset", ">=", "0", "&&", "\"Unexpected negative offset from SP\"", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "true", ")", ";", "if", "(", "HasOffsetOp", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", "/", "OffsetScale", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "AArch64", "AArch64", "0", "\"Cannot deal with nonzero SPAdj yet\"", "AArch64", "AArch64", "0", "1", "0", "1", "1", "1", "AArch64", "AArch64", "AArch64::ADDxxi_lsl0_s", "0", "0xfff", "1", "0", "0", "AArch64::GPR64RegClass", "0", "0", "\"Unexpected negative offset from SP\"", "1" ]

[]

[ "<s>", "const", "MCSection", "*", "X86ELFMCAsmInfo", "::", "getNonexecutableStackSection", "(", "MCContext", "&", "Ctx", ")", "const", "{", "return", "Ctx", ".", "getELFSection", "(", "\".note.GNU-stack\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "this", "method", "to", "specify", "a", "section", "to", "switch", "to", "if", "the", "translation", "unit", "does", "n't", "have", "any", "trampolines", "that", "require", "an", "executable", "stack", "." ]

[ "X86", "X86", "\".note.GNU-stack\"", "0" ]

[]

[ "<s>", "void", "MCS51PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51" ]

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".arch\"", ")", "parseDirectiveArch", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cpu\"", ")", "parseDirectiveCPU", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "parseDirectiveLtorg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".unreq\"", ")", "parseDirectiveUnreq", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".inst\"", ")", "parseDirectiveInst", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_negate_ra_state\"", ")", "parseDirectiveCFINegateRAState", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_b_key_frame\"", ")", "parseDirectiveCFIBKeyFrame", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".arch_extension\"", ")", "parseDirectiveArchExtension", "(", "Loc", ")", ";", "else", "if", "(", "IsMachO", ")", "{", "if", "(", "IDVal", "==", "MCLOHDirectiveName", "(", ")", ")", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "else", "return", "true", ";", "}", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AArch64", "AArch64", "\".arch\"", "\".cpu\"", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"", "\".cfi_negate_ra_state\"", "\".cfi_b_key_frame\"", "\".arch_extension\"" ]

[]

[ "<s>", "void", "emitBytes", "(", "StringRef", "Data", ")", "override", "{", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "ix86_split_copysign_const", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "op0", ",", "mask", ",", "x", ";", "dest", "=", "operands", "[", "0", "]", ";", "op0", "=", "operands", "[", "1", "]", ";", "mask", "=", "operands", "[", "3", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "vmode", "=", "GET_MODE", "(", "mask", ")", ";", "dest", "=", "simplify_gen_subreg", "(", "vmode", ",", "dest", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "if", "(", "op0", "!=", "CONST0_RTX", "(", "vmode", ")", ")", "{", "x", "=", "gen_rtx_IOR", "(", "vmode", ",", "dest", ",", "op0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "}", "}", "</s>" ]

[ "Deconstruct", "a", "copysign", "operation", "into", "bit", "masks", ".", "Operand", "0", "is", "known", "to", "be", "a", "constant", ",", "and", "so", "has", "already", "been", "expanded", "into", "a", "vector", "constant", "." ]

[ "i386", "0", "1", "3", "0" ]

[]

[ "<s>", "CCAssignFn", "*", "AArch64FastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "WebKit_JS", ")", "return", "CC_AArch64_WebKit_JS", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CC_AArch64_GHC", ";", "if", "(", "CC", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CC_AArch64_Win64_CFGuard_Check", ";", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "CC_AArch64_DarwinPCS", ":", "CC_AArch64_AAPCS", ";", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

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

[]

[ "<s>", "int", "msp430_hard_regno_nregs_has_padding", "(", "int", "regno", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "PSImode", "&&", "msp430x", ")", "return", "1", ";", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS_HAS_PADDING", "." ]

[ "msp430", "1", "1" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "KILLGT", ")", "{", "return", "false", ";", "}", "else", "{", "return", "AMDGPUInstrInfo", "::", "isPredicable", "(", "MI", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "R600" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", "||", "Opc", "==", "X86", "::", "TCRETURNmi", "||", "Opc", "==", "X86", "::", "TCRETURNmi64", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "unsigned", "IgnoredFrameReg", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LOCAL_ESCAPE", ")", "{", "MachineOperand", "&", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "IgnoredFrameReg", ")", ";", "FI", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "Opc", "==", "X86", "::", "LEA64_32r", "&&", "X86", "::", "GR32RegClass", ".", "contains", "(", "BasePtr", ")", ")", "BasePtr", "=", "getX86SubSuperRegister", "(", "BasePtr", ",", "64", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "IgnoredFrameReg", ")", ";", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "STACKMAP", "||", "Opc", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "assert", "(", "BasePtr", "==", "FramePtr", "&&", "\"Expected the FP as base register\"", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "FIOffset", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "X86", "X86", "X86", "X86::TAILJMPm64", "X86::TAILJMPm", "X86::TCRETURNmi", "X86::TCRETURNmi64", "0", "0", "X86::LEA64_32r", "X86::GR32RegClass", "X86", "64", "\"Expected the FP as base register\"", "1", "1", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "bool", "xtensa_split1_finished_p", "(", "void", ")", "{", "return", "cfun", "&&", "(", "cfun", "->", "curr_properties", "&", "PROP_rtl_split_insns", ")", ";", "}", "</s>" ]

[ "Return", "true", "after", "``", "split1", "''", "pass", "has", "been", "finished", "." ]

[ "xtensa" ]

[]

[ "<s>", "static", "void", "cris_function_arg_advance", "(", "cumulative_args_t", "ca_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "ca", "->", "regs", "+=", "(", "3", "+", "CRIS_FUNCTION_ARG_SIZE", "(", "mode", ",", "type", ")", ")", "/", "4", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "cris", "3", "4" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "IsDesirableToPromoteOp", "(", "SDValue", "Op", ",", "EVT", "&", "PVT", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "auto", "IsFoldableRMW", "=", "[", "]", "(", "SDValue", "Load", ",", "SDValue", "Op", ")", "{", "if", "(", "!", "Op", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "SDNode", "*", "User", "=", "*", "Op", "->", "use_begin", "(", ")", ";", "if", "(", "!", "ISD", "::", "isNormalStore", "(", "User", ")", ")", "return", "false", ";", "auto", "*", "Ld", "=", "cast", "<", "LoadSDNode", ">", "(", "Load", ")", ";", "auto", "*", "St", "=", "cast", "<", "StoreSDNode", ">", "(", "User", ")", ";", "return", "Ld", "->", "getBasePtr", "(", ")", "==", "St", "->", "getBasePtr", "(", ")", ";", "}", ";", "bool", "Commute", "=", "false", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "break", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "MayFoldLoad", "(", "N0", ")", "&&", "IsFoldableRMW", "(", "N0", ",", "Op", ")", ")", "return", "false", ";", "break", ";", "}", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "Commute", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SUB", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "if", "(", "MayFoldLoad", "(", "N1", ")", "&&", "(", "!", "Commute", "||", "!", "isa", "<", "ConstantSDNode", ">", "(", "N0", ")", "||", "(", "Op", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "MUL", "&&", "IsFoldableRMW", "(", "N1", ",", "Op", ")", ")", ")", ")", "return", "false", ";", "if", "(", "MayFoldLoad", "(", "N0", ")", "&&", "(", "(", "Commute", "&&", "!", "isa", "<", "ConstantSDNode", ">", "(", "N1", ")", ")", "||", "(", "Op", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "MUL", "&&", "IsFoldableRMW", "(", "N0", ",", "Op", ")", ")", ")", ")", "return", "false", ";", "}", "}", "PVT", "=", "MVT", "::", "i32", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "." ]

[ "X86", "X86", "MVT::i16", "ISD::isNormalStore", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SHL", "ISD::SRL", "0", "ISD::ADD", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SUB", "0", "1", "ISD::MUL", "ISD::MUL", "MVT::i32" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SystemZ Assembly Printer\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ Assembly Printer\"" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enablePostRAScheduler", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "new", "MachObjectWriter", "(", "OS", ",", "true", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "static", "enum", "rtx_code", "ix86_prepare_fp_compare_args", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "pop0", ",", "rtx", "*", "pop1", ")", "{", "enum", "machine_mode", "fpcmp_mode", "=", "ix86_fp_compare_mode", "(", "code", ")", ";", "rtx", "op0", "=", "*", "pop0", ",", "op1", "=", "*", "pop1", ";", "enum", "machine_mode", "op_mode", "=", "GET_MODE", "(", "op0", ")", ";", "int", "is_sse", "=", "TARGET_SSE_MATH", "&&", "SSE_FLOAT_MODE_P", "(", "op_mode", ")", ";", "if", "(", "!", "is_sse", "&&", "(", "fpcmp_mode", "==", "CCFPUmode", "||", "(", "op_mode", "==", "XFmode", "&&", "!", "(", "standard_80387_constant_p", "(", "op0", ")", "==", "1", "||", "standard_80387_constant_p", "(", "op1", ")", "==", "1", ")", "&&", "GET_CODE", "(", "op1", ")", "!=", "FLOAT", ")", "||", "ix86_use_fcomi_compare", "(", "code", ")", ")", ")", "{", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "else", "{", "if", "(", "standard_80387_constant_p", "(", "op0", ")", "==", "0", "||", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "!", "(", "standard_80387_constant_p", "(", "op1", ")", "==", "0", "||", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", ")", ")", "{", "rtx", "tmp", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "}", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", ")", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "if", "(", "CONSTANT_P", "(", "op1", ")", ")", "{", "int", "tmp", "=", "standard_80387_constant_p", "(", "op1", ")", ";", "if", "(", "tmp", "==", "0", ")", "op1", "=", "validize_mem", "(", "force_const_mem", "(", "op_mode", ",", "op1", ")", ")", ";", "else", "if", "(", "tmp", "==", "1", ")", "{", "if", "(", "TARGET_CMOVE", ")", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "else", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "}", "if", "(", "ix86_fp_comparison_cost", "(", "code", ")", ">", "ix86_fp_comparison_cost", "(", "swap_condition", "(", "code", ")", ")", "&&", "(", "GET_CODE", "(", "op1", ")", "==", "REG", "||", "!", "no_new_pseudos", ")", ")", "{", "rtx", "tmp", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", ")", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "}", "*", "pop0", "=", "op0", ";", "*", "pop1", "=", "op1", ";", "return", "code", ";", "}", "</s>" ]

[ "Swap", ",", "force", "into", "registers", ",", "or", "otherwise", "massage", "the", "two", "operands", "to", "a", "fp", "comparison", ".", "The", "operands", "are", "updated", "in", "place", ";", "the", "new", "comparsion", "code", "is", "returned", "." ]

[ "i386", "1", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "int", "small_data_operand", "(", "rtx", "op", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "sym_ref", ";", "if", "(", "rs6000_sdata", "==", "SDATA_NONE", "||", "rs6000_sdata", "==", "SDATA_DATA", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "0", ";", "if", "(", "TARGET_SPE", "&&", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym_ref", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "PLUS", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "!=", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "0", ";", "else", "{", "rtx", "sum", "=", "XEXP", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "summand", ";", "summand", "=", "INTVAL", "(", "XEXP", "(", "sum", ",", "1", ")", ")", ";", "if", "(", "summand", "<", "0", "||", "summand", ">", "g_switch_value", ")", "return", "0", ";", "sym_ref", "=", "XEXP", "(", "sum", ",", "0", ")", ";", "}", "return", "SYMBOL_REF_SMALL_P", "(", "sym_ref", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "for", "an", "operand", "in", "small", "memory", "on", "V.4/eabi", "." ]

[ "powerpcspe", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "AMDGPUCommonSubtarget", "::", "getOccupancyWithLocalMemSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "getOccupancyWithLocalMemSize", "(", "MFI", "->", "getLDSSize", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "}", "</s>" ]

[ "Inverse", "of", "getMaxLocalMemWithWaveCount", "." ]

[ "AMDGPU", "AMDGPU", "SI" ]

[]

[ "<s>", "static", "void", "rl78_note_reg_set", "(", "char", "*", "dead", ",", "rtx", "d", ",", "rtx", "insn", ")", "{", "int", "r", ",", "i", ";", "bool", "is_dead", ";", "if", "(", "GET_CODE", "(", "d", ")", "==", "MEM", ")", "rl78_note_reg_uses", "(", "dead", ",", "XEXP", "(", "d", ",", "0", ")", ",", "insn", ")", ";", "if", "(", "GET_CODE", "(", "d", ")", "!=", "REG", ")", "return", ";", "r", "=", "REGNO", "(", "d", ")", ";", "is_dead", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "d", ")", ")", ";", "i", "++", ")", "if", "(", "!", "dead", "[", "r", "+", "i", "]", ")", "is_dead", "=", "false", ";", "if", "(", "is_dead", ")", "add_reg_note", "(", "insn", ",", "REG_UNUSED", ",", "gen_rtx_REG", "(", "GET_MODE", "(", "d", ")", ",", "r", ")", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"note set reg %d size %d\\n\"", ",", "r", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "d", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "d", ")", ")", ";", "i", "++", ")", "dead", "[", "r", "+", "i", "]", "=", "1", ";", "}", "</s>" ]

[ "Like", "the", "previous", "function", ",", "but", "scan", "for", "SETs", "instead", "." ]

[ "rl78", "0", "0", "\"note set reg %d size %d\\n\"", "0", "1" ]

[]

[ "<s>", "bool", "MSP430AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0" ]

[]

[ "<s>", "static", "void", "emit_store_conditional", "(", "machine_mode", "mode", ",", "rtx", "res", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_store_conditional_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_store_conditional_di", ";", "emit_insn", "(", "fn", "(", "res", ",", "mem", ",", "val", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "store-conditional", "instruction", "in", "MODE", "." ]

[ "alpha" ]

[]

[ "<s>", "MSP430Subtarget", "&", "MSP430Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "ExtendedInsts", "=", "false", ";", "HWMultMode", "=", "NoHWMult", ";", "StringRef", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"msp430\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "HWMultModeOption", "!=", "NoHWMult", ")", "HWMultMode", "=", "HWMultModeOption", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "MSP430", "MSP430", "MSP430", "\"msp430\"" ]

[]

[ "<s>", "static", "rtx", "shared_prop_gen", "(", "rtx", "reg", ",", "propagate_mask", "pm", ",", "unsigned", "rep", ",", "void", "*", "data_", ",", "bool", "vector", ")", "{", "broadcast_data_t", "*", "data", "=", "(", "broadcast_data_t", "*", ")", "data_", ";", "if", "(", "pm", "&", "PM_loop_begin", ")", "{", "unsigned", "align", "=", "GET_MODE_ALIGNMENT", "(", "GET_MODE", "(", "reg", ")", ")", "/", "BITS_PER_UNIT", ";", "oacc_bcast_align", "=", "MAX", "(", "oacc_bcast_align", ",", "align", ")", ";", "data", "->", "offset", "=", "ROUND_UP", "(", "data", "->", "offset", ",", "align", ")", ";", "data", "->", "ptr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "return", "gen_adddi3", "(", "data", "->", "ptr", ",", "data", "->", "base", ",", "GEN_INT", "(", "data", "->", "offset", ")", ")", ";", "}", "else", "if", "(", "pm", "&", "PM_loop_end", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "GET_MODE", "(", "data", "->", "ptr", ")", ",", "data", "->", "ptr", ")", ";", "data", "->", "ptr", "=", "NULL_RTX", ";", "return", "clobber", ";", "}", "else", "return", "nvptx_gen_shared_bcast", "(", "reg", ",", "pm", ",", "rep", ",", "data", ",", "vector", ")", ";", "}", "</s>" ]

[ "Worker", "for", "nvptx_shared_propagate", "." ]

[ "nvptx" ]

[]

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

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

[ "rvex", "rvex" ]

[]

[ "<s>", "rtx", "s390_return_addr_rtx", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "int", "offset", ";", "rtx", "addr", ";", "if", "(", "!", "TARGET_BACKCHAIN", "&&", "count", ">", "0", ")", "return", "NULL_RTX", ";", "if", "(", "count", "==", "0", ")", "{", "if", "(", "TARGET_CPU_ZARCH", ")", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_REGNUM", ")", ";", "else", "{", "cfun_frame_layout", ".", "save_return_addr_p", "=", "true", ";", "return", "gen_rtx_MEM", "(", "Pmode", ",", "return_address_pointer_rtx", ")", ";", "}", "}", "if", "(", "TARGET_PACKED_STACK", ")", "offset", "=", "-", "2", "*", "UNITS_PER_LONG", ";", "else", "offset", "=", "RETURN_REGNUM", "*", "UNITS_PER_LONG", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "frame", ",", "offset", ")", ";", "addr", "=", "memory_address", "(", "Pmode", ",", "addr", ")", ";", "return", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "representing", "the", "value", "of", "the", "return", "address", "for", "the", "frame", "COUNT", "steps", "up", "from", "the", "current", "frame", ".", "FRAME", "is", "the", "frame", "pointer", "of", "that", "frame", "." ]

[ "s390", "0", "0", "2" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "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", "'c'", ":", "break", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "O", "<<", "\"i\"", ";", "return", "false", ";", "case", "'x'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ";", "if", "(", "PPCInstrInfo", "::", "isVRRegister", "(", "Reg", ")", ")", "Reg", "=", "PPC", "::", "VSX32", "+", "(", "Reg", "-", "PPC", "::", "V0", ")", ";", "else", "if", "(", "PPCInstrInfo", "::", "isVFRegister", "(", "Reg", ")", ")", "Reg", "=", "PPC", "::", "VSX32", "+", "(", "Reg", "-", "PPC", "::", "VF0", ")", ";", "const", "char", "*", "RegName", ";", "RegName", "=", "PPCInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "RegName", "=", "PPCRegisterInfo", "::", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "1", "0", "0", "1", "1", "\"i\"", "PPC", "PPC::VSX32", "PPC::V0", "PPC", "PPC::VSX32", "PPC::VF0", "PPC", "PPC" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU16RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "GPR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "GPR64RegClass", ")", ";", "case", "'l'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO", ",", "&", "Mips", "::", "LORegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO64", ",", "&", "Mips", "::", "LORegs64RegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "0", "MVT::i32", "MVT::i16", "MVT::i8", "Mips", "0U", "Mips::CPU16RegsRegClass", "0U", "Mips::GPR32RegClass", "MVT::i64", "Mips", "0U", "Mips::GPR32RegClass", "MVT::i64", "Mips", "0U", "Mips::GPR64RegClass", "0u", "0", "MVT::f32", "0U", "Mips::FGR32RegClass", "MVT::f64", "0U", "Mips::FGR64RegClass", "0U", "Mips::AFGR64RegClass", "MVT::i32", "Mips::T9", "Mips::GPR32RegClass", "MVT::i64", "\"Unexpected type.\"", "Mips::T9_64", "Mips::GPR64RegClass", "MVT::i32", "Mips::LO", "Mips::LORegsRegClass", "Mips::LO64", "Mips::LORegs64RegClass", "0u", "0" ]

[]

[ "<s>", "void", "PatmosInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstPrefix", "(", "MI", ",", "O", ")", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "if", "(", "!", "isBundled", "(", "MI", ")", "&&", "InBundle", ")", "{", "O", "<<", "\" }\"", ";", "InBundle", "=", "false", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Patmos", "Patmos", "\" }\"" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "X86RegisterInfo", "*", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getGPRsForTailCall", "(", "*", "MF", ")", ";", "unsigned", "Opc", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", "&&", "CS", "!=", "X86", "::", "RIP", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "X86", "0", "0", "X86::RET", "X86::RETL", "X86::RETQ", "X86::RETIL", "X86::RETIQ", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "X86::RIP", "0" ]

[]

[ "<s>", "MachineInstr", "*", "SparcInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FI", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "unsigned", "OpNum", "=", "Ops", "[", "0", "]", ";", "bool", "isFloat", "=", "false", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "SP", "::", "ORrr", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "SP", "::", "G0", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "OpNum", "==", "0", ")", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "else", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SP", "::", "LDri", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "break", ";", "case", "SP", "::", "FMOVS", ":", "isFloat", "=", "true", ";", "case", "SP", "::", "FMOVD", ":", "if", "(", "OpNum", "==", "0", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "SP", "::", "STFri", ":", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "SP", "::", "LDFri", ":", "SP", "::", "LDDFri", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "break", ";", "}", "return", "NewMI", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "0", "SP::ORrr", "1", "1", "SP::G0", "0", "2", "0", "SP::STri", "0", "2", "SP::LDri", "0", "0", "SP::FMOVS", "SP::FMOVD", "0", "1", "1", "SP::STFri", "SP::STDFri", "0", "0", "0", "SP::LDFri", "SP::LDDFri", "0" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "||", "hasFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Fix loop entry to simplify codegen\"", ";", "}", "</s>" ]

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

[ "TVM", "\"Fix loop entry to simplify codegen\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "{", "return", "isShuffleMaskLegal", "(", "Mask", ",", "VT", ")", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "Optional", "<", "DestSourcePair", ">", "Mips16InstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "return", "None", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "Mips", "Mips", "0", "1" ]

[]

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

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "Nyuzi" ]

[]

[ "<s>", "SDValue", "VideoCore4TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "PtrVT", "=", "getPointerTy", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", "->", "getGlobal", "(", ")", ";", "return", "DAG", ".", "getNode", "(", "VideoCore4ISD", "::", "GLOBAL", ",", "dl", ",", "PtrVT", ",", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "dl", ",", "PtrVT", ")", ")", ";", "}", "case", "ISD", "::", "FRAMEADDR", ":", "assert", "(", "false", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "VideoCore4", "VideoCore4", "ISD::VAARG", "ISD::VASTART", "ISD::BR_JT", "ISD::GlobalAddress", "VideoCore4ISD::GLOBAL", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]

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

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

[ "AMDGPU", "SI", "1" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "auto", "ValSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "auto", "LocSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "ValSize", "<=", "64", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "LocSize", "<=", "64", "&&", "\"Unsupported location size\"", ")", ";", "markPhysRegUsed", "(", "PhysReg", ")", ";", "if", "(", "ValSize", "==", "LocSize", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "else", "{", "assert", "(", "ValSize", "<", "LocSize", "&&", "\"Extensions not supported\"", ")", ";", "auto", "PhysRegToVReg", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "::", "scalar", "(", "LocSize", ")", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "PhysRegToVReg", ")", ";", "}", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "64", "\"Unsupported value size\"", "64", "\"Unsupported location size\"", "\"Extensions not supported\"" ]

[]

[ "<s>", "bool", "ARM64FastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "ARM64", "ARM64", "MVT::Other", "MVT::f128" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isTerminator", "(", ")", "||", "MI", "->", "isLabel", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MI", ";", "while", "(", "++", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isDebugValue", "(", ")", ")", ";", "if", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "return", "true", ";", "if", "(", "MI", "->", "definesRegister", "(", "ARM", "::", "SP", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "ARM", "ARM", "ARM::t2IT", "ARM::SP" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonExpandPredSpillCode", "(", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ",", "false", ")", ";", "if", "(", "EnableGenMux", ")", "addPass", "(", "createHexagonGenMux", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ",", "false", ")", ";", "}", "addPass", "(", "createHexagonCallFrameInformation", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MBlaze", "::", "NOP", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "MBlaze", "MBlaze", "MBlaze::NOP" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ISD", "::", "INLINEASM", ")", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "if", "(", "isHvxOperation", "(", "Op", ")", ")", "return", "LowerHvxOperation", "(", "Op", ",", "DAG", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dumpr", "(", "&", "DAG", ")", ";", "if", "(", "Opc", ">", "HexagonISD", "::", "OP_BEGIN", "&&", "Opc", "<", "HexagonISD", "::", "OP_END", ")", "errs", "(", ")", "<<", "\"Error: check for a non-legal type in this operation\\n\"", ";", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "LowerINSERT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "LowerBITCAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerVECTOR_SHIFT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "return", "LowerREADCYCLECOUNTER", "(", "Op", ",", "DAG", ")", ";", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Hexagon", "Hexagon", "ISD::INLINEASM", "HexagonISD::OP_BEGIN", "HexagonISD::OP_END", "\"Error: check for a non-legal type in this operation\\n\"", "\"Should not custom lower this!\"", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::BITCAST", "ISD::SRA", "ISD::SHL", "ISD::SRL", "ISD::ConstantPool", "ISD::JumpTable", "ISD::EH_RETURN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GLOBAL_OFFSET_TABLE", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::SETCC", "ISD::VSELECT", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "ISD::PREFETCH", "ISD::READCYCLECOUNTER" ]

[]

[ "<s>", "__inline__", "static", "float", "sh_media_FMAC_S", "(", "float", "fg", ",", "float", "fh", ",", "float", "fq", ")", "{", "float", "res", ";", "__asm__", "(", "\"fmac.s\t%1, %2, %0\"", ":", "\"=f\"", "(", "res", ")", ":", "\"f\"", "(", "fg", ")", ",", "\"f\"", "(", "fh", ")", ",", "\"0\"", "(", "fq", ")", ")", ";", "return", "res", ";", "}", "</s>" ]

[ "This", "gives", "different", "results", "for", "-O0" ]

[ "sh", "\"fmac.s\t%1, %2, %0\"", "\"=f\"", "\"f\"", "\"f\"", "\"0\"" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "ARM", "0", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "static", "rtx", "frv_legitimize_argument", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "arg", ")", "{", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "mode", ";", "if", "(", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "arg", ",", "mode", ")", ")", "return", "arg", ";", "else", "return", "copy_to_mode_reg", "(", "mode", ",", "arg", ")", ";", "}", "</s>" ]

[ "Given", "that", "ARG", "is", "being", "passed", "as", "operand", "OPNUM", "to", "instruction", "ICODE", ",", "check", "whether", "ARG", "satisfies", "the", "operand", "'s", "constraints", ".", "If", "it", "does", "n't", ",", "copy", "ARG", "to", "a", "temporary", "register", "and", "return", "that", ".", "Otherwise", "return", "ARG", "itself", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "TPCMemorySize", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "getTargetLowering", "(", ")", "->", "getTargetMachine", "(", ")", ".", "Options", ".", "LocalVectorMemory", ")", "{", "for", "(", "auto", "&", "BB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "BB", ")", "{", "if", "(", "TPCII", "::", "isLookup", "(", "MI", ".", "getDesc", "(", ")", ")", ")", "{", "Subtarget", "->", "getFrameLowering", "(", ")", "->", "setMaxVectorMemory", "(", "Subtarget", "->", "getDefaultSmallVLMSize", "(", ")", ")", ";", "break", ";", "}", "}", "}", "}", "setMemorySize", "(", "*", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "void", "ARCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createARCExpandPseudosPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "ARC", "ARC", "ARC" ]

[]

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

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "inline", "void", "X86EncodeLiteralsPass", "::", "buildXor", "(", "MachineInstr", "&", "MI", ",", "unsigned", "Index", ",", "uint64_t", "Operand", ")", "{", "MachineBasicBlock", "*", "PMBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "Iter", "=", "skip", "(", "PMBB", ",", "Index", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "unsigned", "XOROpc", "=", "getXorOpc", "(", "MI", ")", ";", "addRegOffset", "(", "BuildMI", "(", "*", "PMBB", ",", "Iter", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "XOROpc", ")", ")", ",", "X86", "::", "RBP", ",", "true", ",", "Offset", ")", ".", "addImm", "(", "Operand", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "Res", "=", "G_XOR", "Op0", ",", "Op1", "." ]

[ "X86", "X86", "3", "X86::RBP" ]

[]

[ "<s>", "TargetTransformInfo", "FPGATargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "FPGATTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "FPGA", "FPGA", "FPGA" ]

[]

[ "<s>", "static", "tree", "ix86_builtin_reciprocal", "(", "tree", "fndecl", ")", "{", "switch", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "IX86_BUILTIN_SQRTPS_NR", ":", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_RSQRTPS_NR", ")", ";", "case", "IX86_BUILTIN_SQRTPS_NR256", ":", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_RSQRTPS_NR256", ")", ";", "default", ":", "return", "NULL_TREE", ";", "}", "}", "</s>" ]

[ "Returns", "a", "code", "for", "a", "target-specific", "builtin", "that", "implements", "reciprocal", "of", "the", "function", ",", "or", "NULL_TREE", "if", "not", "available", "." ]

[ "i386" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Val", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADDE", ":", "return", "performADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "performSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "performMULCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "this", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "{", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "return", "Val", ";", "return", "MipsTargetLowering", "::", "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", "." ]

[ "Mips", "Mips", "ISD::ADDE", "ISD::SUBE", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::SETCC", "Mips" ]

[]

[ "<s>", "static", "void", "find_regmode_weight", "(", "basic_block", "b", ",", "machine_mode", "mode", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next_tail", ",", "*", "head", ",", "*", "tail", ";", "get_ebb_head_tail", "(", "b", ",", "b", ",", "&", "head", ",", "&", "tail", ")", ";", "next_tail", "=", "NEXT_INSN", "(", "tail", ")", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "next_tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "mode", "==", "SFmode", ")", "INSN_REGMODE_WEIGHT", "(", "insn", ",", "mode", ")", "=", "find_insn_regmode_weight", "(", "insn", ",", "mode", ")", "+", "2", "*", "find_insn_regmode_weight", "(", "insn", ",", "DFmode", ")", ";", "else", "if", "(", "mode", "==", "SImode", ")", "INSN_REGMODE_WEIGHT", "(", "insn", ",", "mode", ")", "=", "find_insn_regmode_weight", "(", "insn", ",", "mode", ")", "+", "2", "*", "find_insn_regmode_weight", "(", "insn", ",", "DImode", ")", ";", "}", "}", "</s>" ]

[ "Calculate", "regmode", "weights", "for", "all", "insns", "of", "a", "basic", "block", "." ]

[ "sh", "2", "2" ]

[]

[ "<s>", "int", "cr16_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", ")", "&&", "(", "regno", "==", "11", ")", ")", "return", "0", ";", "if", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", "{", "if", "(", "(", "regno", ">", "8", ")", "||", "(", "regno", "&", "1", ")", ")", "return", "0", ";", "return", "1", ";", "}", "if", "(", "(", "TARGET_INT32", ")", "&&", "(", "(", "regno", ">=", "12", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "4", ")", ")", ")", "return", "0", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

[ "cr16", "4", "11", "0", "8", "1", "0", "1", "12", "4", "0", "0", "1" ]

[]

[ "<s>", "bool", "ix86_expand_int_addcc", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "flags", ";", "rtx", "(", "*", "insn", ")", "(", "machine_mode", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "compare_op", ";", "rtx", "val", "=", "const0_rtx", ";", "bool", "fpcmp", "=", "false", ";", "machine_mode", "mode", ";", "rtx", "op0", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ";", "if", "(", "operands", "[", "3", "]", "!=", "const1_rtx", "&&", "operands", "[", "3", "]", "!=", "constm1_rtx", ")", "return", "false", ";", "if", "(", "!", "ix86_expand_carry_flag_compare", "(", "code", ",", "op0", ",", "op1", ",", "&", "compare_op", ")", ")", "return", "false", ";", "code", "=", "GET_CODE", "(", "compare_op", ")", ";", "flags", "=", "XEXP", "(", "compare_op", ",", "0", ")", ";", "if", "(", "GET_MODE", "(", "flags", ")", "==", "CCFPmode", ")", "{", "fpcmp", "=", "true", ";", "code", "=", "ix86_fp_compare_code_to_integer", "(", "code", ")", ";", "}", "if", "(", "code", "!=", "LTU", ")", "{", "val", "=", "constm1_rtx", ";", "if", "(", "fpcmp", ")", "PUT_CODE", "(", "compare_op", ",", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "compare_op", ")", ")", ")", ";", "else", "PUT_CODE", "(", "compare_op", ",", "reverse_condition", "(", "GET_CODE", "(", "compare_op", ")", ")", ")", ";", "}", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "(", "code", "==", "LTU", ")", "==", "(", "operands", "[", "3", "]", "==", "constm1_rtx", ")", ")", "insn", "=", "gen_sub3_carry", ";", "else", "insn", "=", "gen_add3_carry", ";", "emit_insn", "(", "insn", "(", "mode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "flags", ",", "compare_op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "conditional", "increment", "or", "decrement", "using", "adb/sbb", "instructions", ".", "The", "default", "case", "using", "setcc", "followed", "by", "the", "conditional", "move", "can", "be", "done", "by", "generic", "code", "." ]

[ "i386", "1", "1", "0", "1", "1", "3", "3", "0", "0", "3", "0", "2" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "IsLittle", ",", "const", "TargetOptions", "&", "Options", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "ARMProcClass", "(", "None", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "Options", ")", ",", "TargetABI", "(", "ARM_ABI_UNKNOWN", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_maybe_emit_fp_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "machine_mode", "compare_mode", "=", "GET_MODE", "(", "op0", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "compare_rtx", ";", "rtx", "cmove_rtx", ";", "rtx", "clobber_rtx", ";", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "return", "0", ";", "if", "(", "!", "(", "compare_mode", "==", "result_mode", "||", "(", "compare_mode", "==", "SFmode", "&&", "result_mode", "==", "DFmode", ")", "||", "(", "compare_mode", "==", "DFmode", "&&", "result_mode", "==", "SFmode", ")", ")", ")", "return", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "GE", ":", "case", "GT", ":", "break", ";", "case", "NE", ":", "case", "LT", ":", "case", "LE", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "return", "false", ";", "}", "compare_rtx", "=", "gen_rtx_fmt_ee", "(", "code", ",", "CCFPmode", ",", "op0", ",", "op1", ")", ";", "cmove_rtx", "=", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "compare_rtx", ",", "true_cond", ",", "false_cond", ")", ")", ";", "clobber_rtx", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "V2DImode", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "cmove_rtx", ",", "clobber_rtx", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Possibly", "emit", "a", "floating", "point", "conditional", "move", "by", "generating", "a", "compare", "that", "sets", "a", "mask", "instruction", "and", "a", "XXSEL", "select", "instruction", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "false", "if", "the", "operation", "can", "not", "be", "generated", ",", "and", "true", "if", "we", "could", "generate", "the", "instruction", "." ]

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

[]

[ "<s>", "RegisterAggr", "&", "RegisterAggr", "::", "clear", "(", "RegisterRef", "RR", ")", "{", "if", "(", "PhysicalRegisterInfo", "::", "isRegMaskId", "(", "RR", ".", "Reg", ")", ")", "{", "const", "uint32_t", "*", "MB", "=", "PRI", ".", "getRegMaskBits", "(", "RR", ".", "Reg", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "PRI", ".", "getTRI", "(", ")", ".", "getNumRegs", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "MB", "[", "i", "/", "32", "]", "&", "(", "1u", "<<", "(", "i", "%", "32", ")", ")", ")", "continue", ";", "clear", "(", "RegisterRef", "(", "i", ",", "LaneBitmask", "::", "getAll", "(", ")", ")", ")", ";", "}", "return", "*", "this", ";", "}", "RegisterRef", "NR", "=", "PRI", ".", "normalize", "(", "RR", ")", ";", "auto", "F", "=", "Masks", ".", "find", "(", "NR", ".", "Reg", ")", ";", "if", "(", "F", "==", "Masks", ".", "end", "(", ")", ")", "return", "*", "this", ";", "LaneBitmask", "NewM", "=", "F", "->", "second", "&", "~", "NR", ".", "Mask", ";", "if", "(", "NewM", ".", "none", "(", ")", ")", "Masks", ".", "erase", "(", "F", ")", ";", "else", "F", "->", "second", "=", "NewM", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "Hexagon", "1", "32", "1u", "32" ]

[]

[ "<s>", "static", "rtx", "m32c_function_arg", "(", "cumulative_args_t", "ca_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "rtx", "rv", "=", "NULL_RTX", ";", "fprintf", "(", "stderr", ",", "\"func_arg %d (%s, %d)\\n\"", ",", "ca", "->", "parm_num", ",", "mode_name", "[", "arg", ".", "mode", "]", ",", "arg", ".", "named", ")", ";", "debug_tree", "(", "arg", ".", "type", ")", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "GEN_INT", "(", "0", ")", ";", "if", "(", "ca", "->", "force_mem", "||", "!", "arg", ".", "named", ")", "{", "fprintf", "(", "stderr", ",", "\"func arg: force %d named %d, mem\\n\"", ",", "ca", "->", "force_mem", ",", "arg", ".", "named", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "arg", ".", "type", "&&", "INTEGRAL_TYPE_P", "(", "arg", ".", "type", ")", "&&", "POINTER_TYPE_P", "(", "arg", ".", "type", ")", ")", "return", "NULL_RTX", ";", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "return", "NULL_RTX", ";", "switch", "(", "ca", "->", "parm_num", ")", "{", "case", "1", ":", "if", "(", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "==", "1", "||", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "==", "2", ")", "rv", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "TARGET_A16", "?", "R1_REGNO", ":", "R0_REGNO", ")", ";", "break", ";", "case", "2", ":", "if", "(", "TARGET_A16", "&&", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "==", "2", ")", "rv", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "R2_REGNO", ")", ";", "break", ";", "}", "debug_rtx", "(", "rv", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Implements", "FUNCTION_ARG", ".", "Arguments", "are", "passed", "partly", "in", "registers", ",", "partly", "on", "stack", ".", "If", "our", "function", "returns", "a", "struct", ",", "a", "pointer", "to", "a", "buffer", "for", "it", "is", "at", "the", "top", "of", "the", "stack", "(", "last", "thing", "pushed", ")", ".", "The", "first", "few", "real", "arguments", "may", "be", "in", "registers", "as", "follows", ":", "R8C/M16C", ":", "arg1", "in", "r1", "if", "it", "'s", "QI", "or", "HI", "(", "else", "it", "'s", "pushed", "on", "stack", ")", "arg2", "in", "r2", "if", "it", "'s", "HI", "(", "else", "pushed", "on", "stack", ")", "rest", "on", "stack", "M32C", ":", "arg1", "in", "r0", "if", "it", "'s", "QI", "or", "HI", "(", "else", "it", "'s", "pushed", "on", "stack", ")", "rest", "on", "stack", "Structs", "are", "not", "passed", "in", "registers", ",", "even", "if", "they", "fit", ".", "Only", "integer", "and", "pointer", "types", "are", "passed", "in", "registers", ".", "Note", "that", "when", "arg1", "does", "n't", "fit", "in", "r1", ",", "arg2", "may", "still", "be", "passed", "in", "r2", "if", "it", "fits", "." ]

[ "m32c", "\"func_arg %d (%s, %d)\\n\"", "0", "\"func arg: force %d named %d, mem\\n\"", "1", "1", "2", "2", "2" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "60", "12" ]

[]

[ "<s>", "static", "bool", "isNodeHidden", "(", "const", "SUnit", "*", "Node", ",", "const", "ScheduleDAGPostRA", "*", "G", ")", "{", "return", "(", "Node", "->", "NumPreds", ">", "10", "||", "Node", "->", "NumSuccs", ">", "10", ")", ";", "}", "</s>" ]

[ "Do", "not", "print", "nodes", "that", "are", "part", "of", "a", "pi-block", "separately", "." ]

[ "Patmos", "10", "10" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "Subtarget", "=", "&", "F", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "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", "Sparc" ]

[]

[ "<s>", "static", "void", "rs6000_print_isa_options", "(", "FILE", "*", "file", ",", "int", "indent", ",", "const", "char", "*", "string", ",", "HOST_WIDE_INT", "flags", ")", "{", "rs6000_print_options_internal", "(", "file", ",", "indent", ",", "string", ",", "flags", ",", "\"-m\"", ",", "&", "rs6000_opt_masks", "[", "0", "]", ",", "ARRAY_SIZE", "(", "rs6000_opt_masks", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "print", "the", "current", "isa", "options", "on", "a", "line", "." ]

[ "powerpcspe", "\"-m\"", "0" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "bool", "HasCall", "=", "false", ";", "unsigned", "NumStores", "=", "0", ";", "for", "(", "auto", "&", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "&", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "HasCall", "=", "true", ";", "if", "(", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", "||", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memset", ")", "NumStores", "++", ";", "}", "else", "{", "HasCall", "=", "true", ";", "}", "}", "if", "(", "isa", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "{", "Type", "*", "MemAccessTy", "=", "I", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "NumStores", "+=", "getMemoryOpCost", "(", "Instruction", "::", "Store", ",", "MemAccessTy", ",", "None", ",", "0", ")", ";", "}", "}", "unsigned", "const", "Max", "=", "(", "NumStores", "?", "(", "12", "/", "NumStores", ")", ":", "UINT_MAX", ")", ";", "if", "(", "HasCall", ")", "{", "UP", ".", "FullUnrollMaxCount", "=", "Max", ";", "UP", ".", "MaxCount", "=", "1", ";", "return", ";", "}", "UP", ".", "MaxCount", "=", "Max", ";", "if", "(", "UP", ".", "MaxCount", "<=", "1", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "75", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "SystemZ", "SystemZ", "0", "Intrinsic::memcpy", "Intrinsic::memset", "0", "0", "12", "1", "1", "75", "4" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Constraint", ".", "length", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'I'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "uint64_t", "CVal", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "isInt", "<", "12", ">", "(", "CVal", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "CVal", ",", "SDLoc", "(", "Op", ")", ",", "Subtarget", ".", "getXLenVT", "(", ")", ")", ")", ";", "}", "return", ";", "case", "'J'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "Subtarget", ".", "getXLenVT", "(", ")", ")", ")", ";", "return", ";", "case", "'K'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "uint64_t", "CVal", "=", "C", "->", "getZExtValue", "(", ")", ";", "if", "(", "isUInt", "<", "5", ">", "(", "CVal", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "CVal", ",", "SDLoc", "(", "Op", ")", ",", "Subtarget", ".", "getXLenVT", "(", ")", ")", ")", ";", "}", "return", ";", "case", "'S'", ":", "if", "(", "const", "auto", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "{", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "GA", "->", "getValueType", "(", "0", ")", ")", ")", ";", "}", "else", "if", "(", "const", "auto", "*", "BA", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "{", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetBlockAddress", "(", "BA", "->", "getBlockAddress", "(", ")", ",", "BA", "->", "getValueType", "(", "0", ")", ")", ")", ";", "}", "return", ";", "default", ":", "break", ";", "}", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "RISCV", "RISCV", "1", "0", "12", "0", "0", "5", "0", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "!", "RunPreEmitPeephole", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "const", "PPCInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "InstrsToErase", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "MachineInstr", "*", "DefMIToErase", "=", "nullptr", ";", "if", "(", "TII", "->", "convertToImmediateForm", "(", "MI", ",", "&", "DefMIToErase", ")", ")", "{", "Changed", "=", "true", ";", "NumRRConvertedInPreEmit", "++", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Converted instruction to imm form: \"", ")", ";", "DEBUG", "(", "MI", ".", "dump", "(", ")", ")", ";", "if", "(", "DefMIToErase", ")", "{", "InstrsToErase", ".", "push_back", "(", "DefMIToErase", ")", ";", "}", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "InstrsToErase", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"PPC pre-emit peephole: erasing instruction: \"", ")", ";", "DEBUG", "(", "MI", "->", "dump", "(", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "NumRemovedInPreEmit", "++", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "4", "\"Converted instruction to imm form: \"", "\"PPC pre-emit peephole: erasing instruction: \"" ]

[]

[ "<s>", "static", "tree", "m68hc11_handle_page0_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "*", "node", ";", "if", "(", "TREE_STATIC", "(", "decl", ")", "||", "DECL_EXTERNAL", "(", "decl", ")", ")", "{", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "6", ",", "\".page0\"", ")", ";", "}", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute ignored\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "tiny_data", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "m68hc11", "6", "\".page0\"", "\"%qs attribute ignored\"" ]

[]

[ "<s>", "const", "char", "*", "avr_out_sign_extend", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "unsigned", "n_src", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "xop", "[", "1", "]", ")", ")", ";", "unsigned", "n_dest", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "xop", "[", "0", "]", ")", ")", ";", "rtx", "r_msb", "=", "all_regs_rtx", "[", "REGNO", "(", "xop", "[", "1", "]", ")", "+", "n_src", "-", "1", "]", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "!=", "REGNO", "(", "xop", "[", "1", "]", ")", ")", "{", "gcc_assert", "(", "n_src", "<=", "2", ")", ";", "if", "(", "n_src", "==", "2", ")", "avr_asm_len", "(", "AVR_HAVE_MOVW", "?", "\"movw %0,%1\"", ":", "\"mov %B0,%B1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "if", "(", "n_src", "==", "1", "||", "!", "AVR_HAVE_MOVW", ")", "avr_asm_len", "(", "\"mov %A0,%A1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "==", "REGNO", "(", "xop", "[", "1", "]", ")", "||", "!", "reg_unused_after", "(", "insn", ",", "r_msb", ")", ")", "{", "avr_asm_len", "(", "\"mov __tmp_reg__,%0\"", ",", "&", "r_msb", ",", "plen", ",", "1", ")", ";", "r_msb", "=", "tmp_reg_rtx", ";", "}", "avr_asm_len", "(", "\"lsl %0\"", ",", "&", "r_msb", ",", "plen", ",", "1", ")", ";", "for", "(", "unsigned", "n", "=", "n_src", ";", "n", "<", "n_dest", ";", "n", "++", ")", "avr_asm_len", "(", "\"sbc %0,%0\"", ",", "&", "all_regs_rtx", "[", "REGNO", "(", "xop", "[", "0", "]", ")", "+", "n", "]", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "sign", "extension", "from", "XOP", "[", "1", "]", "to", "XOP", "[", "0", "]", "and", "return", "``", "''", ".", "If", "PLEN", "==", "NULL", ",", "print", "assembler", "instructions", "to", "perform", "the", "operation", ";", "otherwise", ",", "set", "*", "PLEN", "to", "the", "length", "of", "the", "instruction", "sequence", "(", "in", "words", ")", "as", "printed", "with", "PLEN", "==", "NULL", "." ]

[ "avr", "1", "0", "1", "1", "0", "0", "1", "2", "2", "\"movw %0,%1\"", "\"mov %B0,%B1\"", "1", "1", "\"mov %A0,%A1\"", "1", "0", "1", "\"mov __tmp_reg__,%0\"", "1", "\"lsl %0\"", "1", "\"sbc %0,%0\"", "0", "1", "\"\"" ]

[]

[ "<s>", "void", "AMDGPURegisterBankInfo", "::", "split64BitValueForMapping", "(", "MachineIRBuilder", "&", "B", ",", "SmallVector", "<", "Register", ",", "2", ">", "&", "Regs", ",", "LLT", "HalfTy", ",", "unsigned", "Reg", ")", "const", "{", "assert", "(", "HalfTy", ".", "getSizeInBits", "(", ")", "==", "32", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "B", ".", "getMRI", "(", ")", ";", "unsigned", "LoLHS", "=", "MRI", "->", "createGenericVirtualRegister", "(", "HalfTy", ")", ";", "unsigned", "HiLHS", "=", "MRI", "->", "createGenericVirtualRegister", "(", "HalfTy", ")", ";", "const", "RegisterBank", "*", "Bank", "=", "getRegBank", "(", "Reg", ",", "*", "MRI", ",", "*", "TRI", ")", ";", "MRI", "->", "setRegBank", "(", "LoLHS", ",", "*", "Bank", ")", ";", "MRI", "->", "setRegBank", "(", "HiLHS", ",", "*", "Bank", ")", ";", "Regs", ".", "push_back", "(", "LoLHS", ")", ";", "Regs", ".", "push_back", "(", "HiLHS", ")", ";", "B", ".", "buildInstr", "(", "AMDGPU", "::", "G_UNMERGE_VALUES", ")", ".", "addDef", "(", "LoLHS", ")", ".", "addDef", "(", "HiLHS", ")", ".", "addUse", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Split", "64-bit", "value", "Reg", "into", "two", "32-bit", "halves", "and", "populate", "them", "into", "Regs", "." ]

[ "AMDGPU", "AMDGPU", "2", "32", "AMDGPU::G_UNMERGE_VALUES" ]

[]

[ "<s>", "int", "avr_simplify_comparison_p", "(", "enum", "machine_mode", "mode", ",", "RTX_CODE", "operator", ",", "rtx", "x", ")", "{", "unsigned", "int", "max", "=", "(", "mode", "==", "QImode", "?", "0xff", ":", "mode", "==", "HImode", "?", "0xffff", ":", "mode", "==", "SImode", "?", "0xffffffff", ":", "0", ")", ";", "if", "(", "max", "&&", "operator", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "if", "(", "unsigned_condition", "(", "operator", ")", "!=", "operator", ")", "max", ">>=", "1", ";", "if", "(", "max", "!=", "(", "INTVAL", "(", "x", ")", "&", "max", ")", "&&", "INTVAL", "(", "x", ")", "!=", "0xff", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "0", "if", "undefined", ",", "1", "if", "always", "true", "or", "always", "false", "." ]

[ "avr", "0xff", "0xffff", "0xffffffff", "0", "1", "0xff", "1", "0" ]

[]

[ "<s>", "static", "int", "arc_save_callee_enter", "(", "uint64_t", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ")", "{", "int", "start_reg", "=", "ENTER_LEAVE_START_REG", ";", "int", "end_reg", "=", "ENTER_LEAVE_END_REG", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "nregs", "+=", "save_blink", "?", "1", ":", "0", ";", "nregs", "+=", "save_fp", "?", "1", ":", "0", ";", "if", "(", "offset", ")", "frame_stack_add", "(", "offset", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "(", "save_fp", "?", "1", ":", "0", ")", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "reg", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "nregs", "*", "UNITS_PER_WORD", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "reg", ")", "=", "1", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", "=", "reg", ";", "off", "=", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "save_blink", "=", "false", ";", "}", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "-=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1ULL", "<<", "regno", ")", ";", "}", "if", "(", "save_fp", ")", "{", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "hard_frame_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "save_fp", "=", "false", ";", "}", "gcc_assert", "(", "off", "==", "0", ")", ";", "insn", "=", "frame_insn", "(", "insn", ")", ";", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "frame_allocated", "=", "nregs", "*", "UNITS_PER_WORD", ";", "return", "frame_allocated", "-", "offset", ";", "}", "</s>" ]

[ "ARC", "prologue", ",", "save", "the", "registers", "using", "enter", "instruction", ".", "Leave", "instruction", "can", "also", "save", "$", "blink", "(", "SAVE_BLINK", ")", "and", "$", "fp", "(", "SAVE_FP", ")", "register", "." ]

[ "arc", "0", "1ULL", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "1", "1ULL", "0", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "DecodeStatus", "BPFDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "bool", "IsLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "uint64_t", "Insn", ",", "Hi", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint8_t", "InstClass", "=", "getInstClass", "(", "Insn", ")", ";", "uint8_t", "InstMode", "=", "getInstMode", "(", "Insn", ")", ";", "if", "(", "(", "InstClass", "==", "BPF_LDX", "||", "InstClass", "==", "BPF_STX", ")", "&&", "getInstSize", "(", "Insn", ")", "!=", "BPF_DW", "&&", "(", "InstMode", "==", "BPF_MEM", "||", "InstMode", "==", "BPF_ATOMIC", ")", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "BPF", "::", "ALU32", "]", ")", "Result", "=", "decodeInstruction", "(", "DecoderTableBPFALU3264", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "else", "Result", "=", "decodeInstruction", "(", "DecoderTableBPF64", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "switch", "(", "Instr", ".", "getOpcode", "(", ")", ")", "{", "case", "BPF", "::", "LD_imm64", ":", "case", "BPF", "::", "LD_pseudo", ":", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "16", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Size", "=", "16", ";", "if", "(", "IsLittleEndian", ")", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "0", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "24", ")", ";", "else", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "0", ")", ";", "auto", "&", "Op", "=", "Instr", ".", "getOperand", "(", "1", ")", ";", "Op", ".", "setImm", "(", "Make_64", "(", "Hi", ",", "Op", ".", "getImm", "(", ")", ")", ")", ";", "break", ";", "}", "case", "BPF", "::", "LD_ABS_B", ":", "case", "BPF", "::", "LD_ABS_H", ":", "case", "BPF", "::", "LD_ABS_W", ":", "case", "BPF", "::", "LD_IND_B", ":", "case", "BPF", "::", "LD_IND_H", ":", "case", "BPF", "::", "LD_IND_W", ":", "{", "auto", "Op", "=", "Instr", ".", "getOperand", "(", "0", ")", ";", "Instr", ".", "clear", "(", ")", ";", "Instr", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "BPF", "::", "R6", ")", ")", ";", "Instr", ".", "addOperand", "(", "Op", ")", ";", "break", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF", "BPF", "BPF", "BPF", "BPF", "BPF::ALU32", "BPF", "BPF", "BPF::LD_imm64", "BPF::LD_pseudo", "16", "0", "16", "12", "0", "13", "8", "14", "16", "15", "24", "12", "24", "13", "16", "14", "8", "15", "0", "1", "BPF::LD_ABS_B", "BPF::LD_ABS_H", "BPF::LD_ABS_W", "BPF::LD_IND_B", "BPF::LD_IND_H", "BPF::LD_IND_W", "0", "BPF::R6" ]

[]

[ "<s>", "void", "XNCMFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "XNCM", "XNCM" ]

[]

[ "<s>", "int", "nios2_can_use_return_insn", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "||", "crtl", "->", "profile", ")", "return", "0", ";", "return", "nios2_compute_frame_layout", "(", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "nios2", "0", "0" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "bool", "ContiguousRegs", "=", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "SuperReg", "=", "uniqueSuperReg", "(", "Reg", ",", "TRI", ")", ";", "bool", "CanUseDblStore", "=", "false", ";", "const", "TargetRegisterClass", "*", "SuperRegClass", "=", "nullptr", ";", "if", "(", "ContiguousRegs", "&&", "(", "i", "<", "CSI", ".", "size", "(", ")", "-", "1", ")", ")", "{", "unsigned", "SuperRegNext", "=", "uniqueSuperReg", "(", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ",", "TRI", ")", ";", "SuperRegClass", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "SuperReg", ")", ";", "CanUseDblStore", "=", "(", "SuperRegNext", "==", "SuperReg", ")", ";", "}", "if", "(", "CanUseDblStore", ")", "{", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "SuperReg", ",", "true", ",", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", ",", "SuperRegClass", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "SuperReg", ")", ";", "++", "i", ";", "}", "else", "{", "ContiguousRegs", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "Hexagon", "Hexagon", "0", "1", "1", "1" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "llvm_unreachable", "(", "\"getFixupKindInfo() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "VE", "\"getFixupKindInfo() unimplemented\"" ]

[]

[ "<s>", "bool", "AMDGPUTargetELFStreamer", "::", "EmitHSAMetadata", "(", "std", "::", "shared_ptr", "<", "msgpack", "::", "Node", ">", "&", "HSAMetadataRoot", ",", "bool", "Strict", ")", "{", "V3", "::", "MetadataVerifier", "Verifier", "(", "Strict", ")", ";", "if", "(", "!", "Verifier", ".", "verify", "(", "*", "HSAMetadataRoot", ")", ")", "return", "false", ";", "std", "::", "string", "HSAMetadataString", ";", "raw_string_ostream", "StrOS", "(", "HSAMetadataString", ")", ";", "msgpack", "::", "Writer", "MPWriter", "(", "StrOS", ")", ";", "HSAMetadataRoot", "->", "write", "(", "MPWriter", ")", ";", "auto", "&", "Context", "=", "getContext", "(", ")", ";", "auto", "*", "DescBegin", "=", "Context", ".", "createTempSymbol", "(", ")", ";", "auto", "*", "DescEnd", "=", "Context", ".", "createTempSymbol", "(", ")", ";", "auto", "*", "DescSZ", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "DescEnd", ",", "Context", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "DescBegin", ",", "Context", ")", ",", "Context", ")", ";", "EmitNote", "(", "ElfNote", "::", "NoteNameV3", ",", "DescSZ", ",", "ELF", "::", "NT_AMDGPU_METADATA", ",", "[", "&", "]", "(", "MCELFStreamer", "&", "OS", ")", "{", "OS", ".", "EmitLabel", "(", "DescBegin", ")", ";", "OS", ".", "EmitBytes", "(", "StrOS", ".", "str", "(", ")", ")", ";", "OS", ".", "EmitLabel", "(", "DescEnd", ")", ";", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "HSA", "Metadata", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "Mips" ]

[]

[ "<s>", "static", "void", "maybe_set_link_compat", "(", "void", ")", "{", "}", "</s>" ]

[ "Checks", "if", "logical", "names", "are", "defined", "for", "setting", "system", "library", "path", "and", "linker", "program", "to", "enable", "compatibility", "with", "earlier", "VMS", "versions", "." ]

[ "vms" ]

[]

[ "<s>", "bool", "HexagonRemoveExtendArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "unsigned", "Idx", "=", "1", ";", "for", "(", "Function", "::", "arg_iterator", "AI", "=", "F", ".", "arg_begin", "(", ")", ",", "AE", "=", "F", ".", "arg_end", "(", ")", ";", "AI", "!=", "AE", ";", "++", "AI", ",", "++", "Idx", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "Argument", "*", "Arg", "=", "AI", ";", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", "->", "getType", "(", ")", ")", ")", "{", "for", "(", "auto", "UI", "=", "Arg", "->", "user_begin", "(", ")", ";", "UI", "!=", "Arg", "->", "user_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "I", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "Arg", ",", "I", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "I", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "I", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "F", ".", "getEntryBlock", "(", ")", ".", "begin", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1" ]

[]

[ "<s>", "void", "fr30_expand_prologue", "(", "void", ")", "{", "int", "regno", ";", "rtx", "insn", ";", "if", "(", "!", "current_frame_info", ".", "initialised", ")", "fr30_compute_frame_size", "(", "0", ",", "0", ")", ";", "gcc_assert", "(", "current_frame_info", ".", "total_size", "||", "!", "current_frame_info", ".", "gmask", ")", ";", "if", "(", "current_frame_info", ".", "pretend_size", ")", "{", "int", "regs_to_save", "=", "current_frame_info", ".", "pretend_size", "/", "UNITS_PER_WORD", ";", "for", "(", "regno", "=", "FIRST_ARG_REGNUM", "+", "FR30_NUM_ARG_REGS", ";", "regno", "--", ",", "regs_to_save", "--", ";", ")", "{", "insn", "=", "emit_insn", "(", "gen_movsi_push", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "if", "(", "current_frame_info", ".", "gmask", ")", "{", "for", "(", "regno", "=", "STACK_POINTER_REGNUM", ";", "regno", "--", ";", ")", "{", "if", "(", "(", "current_frame_info", ".", "gmask", "&", "(", "1", "<<", "regno", ")", ")", "!=", "0", ")", "{", "insn", "=", "emit_insn", "(", "gen_movsi_push", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "}", "if", "(", "current_frame_info", ".", "save_rp", ")", "{", "insn", "=", "emit_insn", "(", "gen_movsi_push", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_POINTER_REGNUM", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "current_frame_info", ".", "save_fp", ")", "{", "if", "(", "current_frame_info", ".", "frame_size", "<", "(", "(", "1", "<<", "10", ")", "-", "UNITS_PER_WORD", ")", ")", "{", "int", "enter_size", "=", "current_frame_info", ".", "frame_size", "+", "UNITS_PER_WORD", ";", "rtx", "pattern", ";", "insn", "=", "emit_insn", "(", "gen_enter_func", "(", "GEN_INT", "(", "enter_size", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "{", "int", "x", ";", "for", "(", "x", "=", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "x", "--", ";", ")", "{", "rtx", "part", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "x", ")", ";", "if", "(", "!", "frame_pointer_needed", "&&", "GET_CODE", "(", "part", ")", "==", "SET", "&&", "REGNO", "(", "SET_DEST", "(", "part", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "RTX_FRAME_RELATED_P", "(", "part", ")", "=", "0", ";", "else", "RTX_FRAME_RELATED_P", "(", "part", ")", "=", "1", ";", "}", "}", "}", "else", "{", "insn", "=", "emit_insn", "(", "gen_movsi_push", "(", "frame_pointer_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_movsi", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "}", "if", "(", "current_frame_info", ".", "frame_size", "==", "0", ")", ";", "else", "if", "(", "current_frame_info", ".", "save_fp", "&&", "current_frame_info", ".", "frame_size", "<", "(", "(", "1", "<<", "10", ")", "-", "UNITS_PER_WORD", ")", ")", ";", "else", "if", "(", "current_frame_info", ".", "frame_size", "<=", "512", ")", "{", "insn", "=", "emit_insn", "(", "gen_add_to_stack", "(", "GEN_INT", "(", "-", "current_frame_info", ".", "frame_size", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "insn", "=", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "current_frame_info", ".", "frame_size", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "current_function_profile", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "prologue", ".", "Using", "a", "prologue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "output_function_prologue", "(", ")", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", "." ]

[ "fr30", "0", "0", "1", "1", "0", "1", "1", "1", "10", "1", "0", "0", "0", "1", "1", "1", "0", "1", "10", "512", "1", "1", "1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isThroughputPattern", "(", "MachineCombinerPattern", "Pattern", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "default", ":", "break", ";", "case", "MachineCombinerPattern", "::", "FMULADDS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP2", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4f32_OP2", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "code", "sequence", "can", "improve", "throughput", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalNTStore", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "unsigned", "DataSize", "=", "DL", ".", "getTypeStoreSize", "(", "DataType", ")", ";", "if", "(", "ST", "->", "hasSSE4A", "(", ")", "&&", "(", "DataType", "->", "isFloatTy", "(", ")", "||", "DataType", "->", "isDoubleTy", "(", ")", ")", ")", "return", "true", ";", "if", "(", "Alignment", "<", "DataSize", "||", "DataSize", "<", "4", "||", "DataSize", ">", "32", "||", "!", "isPowerOf2_32", "(", "DataSize", ")", ")", "return", "false", ";", "if", "(", "DataSize", "==", "32", ")", "return", "ST", "->", "hasAVX", "(", ")", ";", "else", "if", "(", "DataSize", "==", "16", ")", "return", "ST", "->", "hasSSE1", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "nontemporal", "store", "." ]

[ "X86", "X86", "4", "32", "32", "16" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'a'", ":", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "return", "true", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "llvm_unreachable", "(", "\"unexpected operand type!\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "printSymbolOperand", "(", "*", "this", ",", "MO", ",", "O", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", ")", "O", "<<", "\"(%rip)\"", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "O", "<<", "'('", ";", "printOperand", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "')'", ";", "return", "false", ";", "}", "case", "'c'", ":", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "printOperand", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "llvm_unreachable", "(", "\"unexpected operand type!\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "printSymbolOperand", "(", "*", "this", ",", "MO", ",", "O", ")", ";", "break", ";", "}", "return", "false", ";", "case", "'A'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'*'", ";", "printOperand", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "*", "this", ",", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "printOperand", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'P'", ":", "printPCRelImm", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'n'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "-", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "O", "<<", "'-'", ";", "}", "}", "printOperand", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ",", "nullptr", ",", "AsmVariant", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "1", "0", "0", "\"unexpected operand type!\"", "\"(%rip)\"", "\"unexpected operand type!\"", "0" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "return", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ">", "64", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

[ "Hexagon", "Hexagon", "64" ]

[]