Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "gimple", "*", "va_list_skip_additions", "(", "tree", "lhs", ")", "{", "gimple", "*", "stmt", ";", "for", "(", ";", ";", ")", "{", "enum", "tree_code", "code", ";", "stmt", "=", "SSA_NAME_DEF_STMT", "(", "lhs", ")", ";", "if", "(", "gimple_code", "(", "stmt", ")", "==", "GIMPLE_PHI", ")", "return", "stmt", ";", "if", "(", "!", "is_gimple_assign", "(", "stmt", ")", "||", "gimple_assign_lhs", "(", "stmt", ")", "!=", "lhs", ")", "return", "NULL", ";", "if", "(", "TREE_CODE", "(", "gimple_assign_rhs1", "(", "stmt", ")", ")", "!=", "SSA_NAME", ")", "return", "stmt", ";", "code", "=", "gimple_assign_rhs_code", "(", "stmt", ")", ";", "if", "(", "!", "CONVERT_EXPR_CODE_P", "(", "code", ")", "&&", "(", "(", "code", "!=", "PLUS_EXPR", "&&", "code", "!=", "POINTER_PLUS_EXPR", ")", "||", "TREE_CODE", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", "!=", "INTEGER_CST", "||", "!", "tree_fits_uhwi_p", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", ")", ")", "return", "stmt", ";", "lhs", "=", "gimple_assign_rhs1", "(", "stmt", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "alpha_stdarg_optimize_hook", ".", "Skip", "over", "casts", "and", "constant", "additions", "." ]

[ "alpha" ]

[]

[ "<s>", "static", "tree", "rx_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "RX_BUILTIN_max", ")", "return", "error_mark_node", ";", "return", "rx_builtins", "[", "code", "]", ";", "}", "</s>" ]

[ "Return", "the", "RX", "builtin", "for", "CODE", "." ]

[ "rx" ]

[]

[ "<s>", "static", "void", "handle_special_swappables", "(", "swap_web_entry", "*", "insn_entry", ",", "unsigned", "i", ")", "{", "rtx_insn", "*", "insn", "=", "insn_entry", "[", "i", "]", ".", "insn", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "switch", "(", "insn_entry", "[", "i", "]", ".", "special_handling", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "SH_CONST_VECTOR", ":", "{", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", ";", "rtx", "rhs", "=", "SET_SRC", "(", "body", ")", ";", "swap_const_vector_halves", "(", "rhs", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Swapping constant halves in insn %d\\n\"", ",", "i", ")", ";", "break", ";", "}", "case", "SH_SUBREG", ":", "adjust_subreg_index", "(", "body", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Adjusting subreg in insn %d\\n\"", ",", "i", ")", ";", "break", ";", "case", "SH_NOSWAP_LD", ":", "permute_load", "(", "insn", ")", ";", "break", ";", "case", "SH_NOSWAP_ST", ":", "permute_store", "(", "insn", ")", ";", "break", ";", "case", "SH_EXTRACT", ":", "adjust_extract", "(", "insn", ")", ";", "break", ";", "case", "SH_SPLAT", ":", "adjust_splat", "(", "insn", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "The", "insn", "described", "by", "INSN_ENTRY", "[", "I", "]", "can", "be", "swapped", ",", "but", "only", "with", "special", "handling", ".", "Take", "care", "of", "that", "here", "." ]

[ "rs6000", "\"Swapping constant halves in insn %d\\n\"", "\"Adjusting subreg in insn %d\\n\"" ]

[]

[ "<s>", "static", "void", "c6x_option_override", "(", "void", ")", "{", "unsigned", "i", ";", "if", "(", "OPTION_SET_P", "(", "c6x_arch_option", ")", ")", "{", "c6x_arch", "=", "all_isas", "[", "c6x_arch_option", "]", ".", "type", ";", "c6x_insn_mask", "&=", "~", "C6X_INSNS_ALL_CPU_BITS", ";", "c6x_insn_mask", "|=", "all_isas", "[", "c6x_arch_option", "]", ".", "features", ";", "}", "c6x_flag_schedule_insns2", "=", "flag_schedule_insns_after_reload", ";", "flag_schedule_insns_after_reload", "=", "0", ";", "c6x_flag_modulo_sched", "=", "flag_modulo_sched", ";", "flag_modulo_sched", "=", "0", ";", "init_machine_status", "=", "c6x_init_machine_status", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "c6x_unit_names", ")", ";", "i", "++", ")", "c6x_unit_codes", "[", "i", "]", "=", "get_cpu_unit_code", "(", "c6x_unit_names", "[", "i", "]", ")", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_DSBT", ")", "{", "error", "(", "\"%<-fpic%> and %<-fPIC%> not supported without %<-mdsbt%> \"", "\"on this target\"", ")", ";", "flag_pic", "=", "0", ";", "}", "c6x_initial_flag_pic", "=", "flag_pic", ";", "if", "(", "TARGET_DSBT", "&&", "!", "flag_pic", ")", "flag_pic", "=", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "c6x", "0", "0", "0", "\"%<-fpic%> and %<-fPIC%> not supported without %<-mdsbt%> \"", "\"on this target\"", "0", "1" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "const", "Value", "*", "Ptr", "=", "LI", "->", "getPointerOperand", "(", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "Ptr", ",", "AM", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "&", "XII", "=", "(", "const", "X86InstrInfo", "&", ")", "TII", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "unsigned", "Alignment", "=", "LI", "->", "getAlignment", "(", ")", ";", "if", "(", "Alignment", "==", "0", ")", "Alignment", "=", "DL", ".", "getABITypeAlignment", "(", "LI", "->", "getType", "(", ")", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "AddrOps", ";", "AM", ".", "getFullAddress", "(", "AddrOps", ")", ";", "MachineInstr", "*", "Result", "=", "XII", ".", "foldMemoryOperandImpl", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ",", "OpNo", ",", "AddrOps", ",", "FuncInfo", ".", "InsertPt", ",", "Size", ",", "Alignment", ",", "true", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "unsigned", "OperandNo", "=", "0", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "I", "=", "Result", "->", "operands_begin", "(", ")", ",", "E", "=", "Result", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "OperandNo", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "AM", ".", "IndexReg", ")", "continue", ";", "unsigned", "IndexReg", "=", "constrainOperandRegClass", "(", "Result", "->", "getDesc", "(", ")", ",", "MO", ".", "getReg", "(", ")", ",", "OperandNo", ")", ";", "if", "(", "IndexReg", "==", "MO", ".", "getReg", "(", ")", ")", "continue", ";", "MO", ".", "setReg", "(", "IndexReg", ")", ";", "}", "Result", "->", "addMemOperand", "(", "*", "FuncInfo", ".", "MF", ",", "createMachineMemOperandFor", "(", "LI", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "8", "0" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "can_be_rotated_to_negative_15bits", "(", "HOST_WIDE_INT", "c", ")", "{", "int", "rot", "=", "0", ";", "bool", "res", "=", "can_be_rotated_to_lowbits", "(", "~", "c", ",", "15", ",", "&", "rot", ")", ";", "return", "res", "&&", "rot", ">", "0", ";", "}", "</s>" ]

[ "Check", "if", "C", "(", "as", "64bit", "integer", ")", "can", "be", "rotated", "to", "a", "negative", "15bits", "constant", "which", "contains", "49bits", "leading", "ones", "and", "15bits", "of", "any", "value", "." ]

[ "rs6000", "0", "15", "0" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "0", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", ")", "{", "uint64_t", "ImmVal", "=", "Imm", ".", "getZExtValue", "(", ")", ";", "if", "(", "ImmVal", "==", "0x100000000ULL", "||", "ImmVal", "==", "0xffffffff", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "And", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", "&&", "isUInt", "<", "32", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", "&&", "Imm", ".", "getZExtValue", "(", ")", "==", "0x80000000", ")", "return", "TTI", "::", "TCC_Free", ";", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "1", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "Idx", "==", "ImmIdx", ")", "{", "int", "NumConstants", "=", "divideCeil", "(", "BitSize", ",", "64", ")", ";", "int", "Cost", "=", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "int", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "return", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "X86", "X86", "0", "0U", "0", "2", "0", "1", "64", "0x100000000ULL", "0xffffffff", "1", "1", "64", "32", "1", "1", "64", "0x80000000", "1", "1", "1", "64", "X86", "X86" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "1", ";", "Info", ".", "size", "=", "2", "*", "VT", ".", "getStoreSize", "(", ")", "-", "1", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_altivec_stvx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "1", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "1", ";", "Info", ".", "size", "=", "2", "*", "VT", ".", "getStoreSize", "(", ")", "-", "1", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "false", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_altivec_lvx", "Intrinsic::ppc_altivec_lvxl", "Intrinsic::ppc_altivec_lvebx", "Intrinsic::ppc_altivec_lvehx", "Intrinsic::ppc_altivec_lvewx", "Intrinsic::ppc_altivec_lvebx", "MVT::i8", "Intrinsic::ppc_altivec_lvehx", "MVT::i16", "Intrinsic::ppc_altivec_lvewx", "MVT::i32", "MVT::v4i32", "ISD::INTRINSIC_W_CHAIN", "0", "1", "2", "1", "1", "Intrinsic::ppc_altivec_stvx", "Intrinsic::ppc_altivec_stvxl", "Intrinsic::ppc_altivec_stvebx", "Intrinsic::ppc_altivec_stvehx", "Intrinsic::ppc_altivec_stvewx", "Intrinsic::ppc_altivec_stvebx", "MVT::i8", "Intrinsic::ppc_altivec_stvehx", "MVT::i16", "Intrinsic::ppc_altivec_stvewx", "MVT::i32", "MVT::v4i32", "ISD::INTRINSIC_VOID", "1", "1", "2", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AMDGPU", "AMDGPU", "\"expected switch to return\"" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "eliminateFI", "(", "MI", ",", "i", ",", "FrameIndex", ",", "stackSize", ",", "spOffset", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "ix86_legitimate_combined_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "(", "INSN_CODE", "(", "insn", ")", "=", "recog", "(", "PATTERN", "(", "insn", ")", ",", "insn", ",", "0", ")", ")", ">=", "0", ")", "{", "int", "i", ";", "extract_insn", "(", "insn", ")", ";", "preprocess_constraints", "(", "insn", ")", ";", "int", "n_operands", "=", "recog_data", ".", "n_operands", ";", "int", "n_alternatives", "=", "recog_data", ".", "n_alternatives", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_operands", ";", "i", "++", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "i", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "const", "operand_alternative", "*", "op_alt", ";", "int", "offset", "=", "0", ";", "bool", "win", ";", "int", "j", ";", "if", "(", "!", "TARGET_AVX", "&&", "VECTOR_MODE_P", "(", "mode", ")", "&&", "misaligned_operand", "(", "op", ",", "mode", ")", ")", "{", "unsigned", "int", "min_align", "=", "get_attr_ssememalign", "(", "insn", ")", ";", "if", "(", "min_align", "==", "0", "||", "MEM_ALIGN", "(", "op", ")", "<", "min_align", ")", "return", "false", ";", "}", "if", "(", "UNARY_P", "(", "op", ")", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "op", ")", ")", "{", "if", "(", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "REGNO", "(", "SUBREG_REG", "(", "op", ")", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "offset", "=", "subreg_regno_offset", "(", "REGNO", "(", "SUBREG_REG", "(", "op", ")", ")", ",", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ",", "SUBREG_BYTE", "(", "op", ")", ",", "GET_MODE", "(", "op", ")", ")", ";", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "}", "if", "(", "!", "(", "REG_P", "(", "op", ")", "&&", "HARD_REGISTER_P", "(", "op", ")", ")", ")", "continue", ";", "op_alt", "=", "recog_op_alt", ";", "win", "=", "!", "n_alternatives", ";", "alternative_mask", "preferred", "=", "get_preferred_alternatives", "(", "insn", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "n_alternatives", ";", "j", "++", ",", "op_alt", "+=", "n_operands", ")", "{", "if", "(", "!", "TEST_BIT", "(", "preferred", ",", "j", ")", ")", "continue", ";", "if", "(", "op_alt", "[", "i", "]", ".", "anything_ok", "||", "(", "op_alt", "[", "i", "]", ".", "matches", "!=", "-", "1", "&&", "operands_match_p", "(", "recog_data", ".", "operand", "[", "i", "]", ",", "recog_data", ".", "operand", "[", "op_alt", "[", "i", "]", ".", "matches", "]", ")", ")", "||", "reg_fits_class_p", "(", "op", ",", "op_alt", "[", "i", "]", ".", "cl", ",", "offset", ",", "mode", ")", ")", "{", "win", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "win", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_LEGITIMATE_COMBINED_INSN", "hook", "." ]

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

[]

[ "<s>", "static", "void", "load_image", "(", "const", "char", "*", "filename", ")", "{", "size_t", "image_size", ";", "Elf64_Ehdr", "*", "image", "=", "(", "void", "*", ")", "read_file", "(", "filename", ",", "&", "image_size", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_create_fn", "(", "HSA_PROFILE_FULL", ",", "HSA_EXECUTABLE_STATE_UNFROZEN", ",", "\"\"", ",", "&", "executable", ")", ",", "\"Initialize GCN executable\"", ")", ";", "hsa_code_object_t", "co", "=", "{", "0", "}", ";", "XHSA", "(", "hsa_fns", ".", "hsa_code_object_deserialize_fn", "(", "image", ",", "image_size", ",", "NULL", ",", "&", "co", ")", ",", "\"Deserialize GCN code object\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_load_code_object_fn", "(", "executable", ",", "device", ",", "co", ",", "\"\"", ")", ",", "\"Load GCN code object\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_freeze_fn", "(", "executable", ",", "\"\"", ")", ",", "\"Freeze GCN executable\"", ")", ";", "hsa_executable_symbol_t", "symbol", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_get_symbol_fn", "(", "executable", ",", "NULL", ",", "\"_init_array.kd\"", ",", "device", ",", "0", ",", "&", "symbol", ")", ",", "\"Find '_init_array' function\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_symbol_get_info_fn", "(", "symbol", ",", "HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT", ",", "&", "init_array_kernel", ")", ",", "\"Extract '_init_array' kernel object kernel object\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_get_symbol_fn", "(", "executable", ",", "NULL", ",", "\"_fini_array.kd\"", ",", "device", ",", "0", ",", "&", "symbol", ")", ",", "\"Find '_fini_array' function\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_symbol_get_info_fn", "(", "symbol", ",", "HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT", ",", "&", "fini_array_kernel", ")", ",", "\"Extract '_fini_array' kernel object kernel object\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_get_symbol_fn", "(", "executable", ",", "NULL", ",", "\"main.kd\"", ",", "device", ",", "0", ",", "&", "symbol", ")", ",", "\"Find 'main' function\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_symbol_get_info_fn", "(", "symbol", ",", "HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT", ",", "&", "main_kernel", ")", ",", "\"Extract 'main' kernel object\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_symbol_get_info_fn", "(", "symbol", ",", "HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_SIZE", ",", "&", "kernarg_segment_size", ")", ",", "\"Extract kernarg segment size\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_symbol_get_info_fn", "(", "symbol", ",", "HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_GROUP_SEGMENT_SIZE", ",", "&", "group_segment_size", ")", ",", "\"Extract group segment size\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_executable_symbol_get_info_fn", "(", "symbol", ",", "HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_PRIVATE_SEGMENT_SIZE", ",", "&", "private_segment_size", ")", ",", "\"Extract private segment size\"", ")", ";", "}", "</s>" ]

[ "Read", "a", "HSA", "Code", "Object", "(", "HSACO", ")", "from", "file", ",", "and", "load", "it", "into", "the", "device", "." ]

[ "gcn", "\"\"", "\"Initialize GCN executable\"", "0", "\"Deserialize GCN code object\"", "\"\"", "\"Load GCN code object\"", "\"\"", "\"Freeze GCN executable\"", "\"_init_array.kd\"", "0", "\"Find '_init_array' function\"", "\"Extract '_init_array' kernel object kernel object\"", "\"_fini_array.kd\"", "0", "\"Find '_fini_array' function\"", "\"Extract '_fini_array' kernel object kernel object\"", "\"main.kd\"", "0", "\"Find 'main' function\"", "\"Extract 'main' kernel object\"", "\"Extract kernarg segment size\"", "\"Extract group segment size\"", "\"Extract private segment size\"" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "NumBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "Idx", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "PowerPC", "0", "1", "8", "0xff" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Dead register definitions\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"Dead register definitions\"" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "Align", ")", ";", "if", "(", "!", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "CalleePopAmount", "==", "0", ")", "{", "assert", "(", "Amount", ">", "-", "0xffffff", "&&", "Amount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "Amount", ",", "TII", ")", ";", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "assert", "(", "CalleePopAmount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "-", "CalleePopAmount", ",", "TII", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "1", "0", "0", "0", "0xffffff", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP", "0", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "int", "m32r_not_same_reg", "(", "rtx", "a", ",", "rtx", "b", ")", "{", "int", "reg_a", "=", "-", "1", ";", "int", "reg_b", "=", "-", "2", ";", "while", "(", "GET_CODE", "(", "a", ")", "==", "SUBREG", ")", "a", "=", "SUBREG_REG", "(", "a", ")", ";", "if", "(", "REG_P", "(", "a", ")", ")", "reg_a", "=", "REGNO", "(", "a", ")", ";", "while", "(", "GET_CODE", "(", "b", ")", "==", "SUBREG", ")", "b", "=", "SUBREG_REG", "(", "b", ")", ";", "if", "(", "REG_P", "(", "b", ")", ")", "reg_b", "=", "REGNO", "(", "b", ")", ";", "return", "reg_a", "!=", "reg_b", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "registers", "contained", "in", "the", "two", "rtl", "expressions", "are", "different", "." ]

[ "m32r", "1", "2" ]

[]

[ "<s>", "bool", "ix86_unary_operator_ok", "(", "enum", "rtx_code", ",", "machine_mode", ",", "rtx", "operands", "[", "2", "]", ")", "{", "if", "(", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "||", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "&&", "!", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "or", "FALSE", "depending", "on", "whether", "the", "unary", "operator", "meets", "the", "appropriate", "constraints", "." ]

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

[]

[ "<s>", "static", "rtx", "nios2_ldst_parallel", "(", "bool", "load_p", ",", "bool", "reg_inc_p", ",", "bool", "offset_inc_p", ",", "rtx", "base_mem", ",", "int", "base_update", ",", "unsigned", "HOST_WIDE_INT", "regmask", ",", "bool", "ret_p", ")", "{", "rtvec", "p", ";", "int", "regno", ",", "b", "=", "0", ",", "i", "=", "0", ",", "n", "=", "0", ",", "len", "=", "popcount_hwi", "(", "regmask", ")", ";", "if", "(", "ret_p", ")", "len", "++", ",", "i", "++", ",", "b", "++", ";", "if", "(", "base_update", "!=", "0", ")", "len", "++", ",", "i", "++", ";", "p", "=", "rtvec_alloc", "(", "len", ")", ";", "for", "(", "regno", "=", "(", "reg_inc_p", "?", "0", ":", "31", ")", ";", "regno", "!=", "(", "reg_inc_p", "?", "32", ":", "-", "1", ")", ";", "regno", "+=", "(", "reg_inc_p", "?", "1", ":", "-", "1", ")", ")", "if", "(", "(", "regmask", "&", "(", "1", "<<", "regno", ")", ")", "!=", "0", ")", "{", "int", "offset", "=", "(", "offset_inc_p", "?", "4", ":", "-", "4", ")", "*", "n", "++", ";", "RTVEC_ELT", "(", "p", ",", "i", "++", ")", "=", "gen_ldst", "(", "load_p", ",", "regno", ",", "base_mem", ",", "offset", ")", ";", "}", "if", "(", "ret_p", ")", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "ret_rtx", ";", "if", "(", "base_update", "!=", "0", ")", "{", "rtx", "reg", ",", "offset", ";", "if", "(", "!", "split_mem_address", "(", "XEXP", "(", "base_mem", ",", "0", ")", ",", "&", "reg", ",", "&", "offset", ")", ")", "gcc_unreachable", "(", ")", ";", "RTVEC_ELT", "(", "p", ",", "b", ")", "=", "gen_rtx_SET", "(", "reg", ",", "plus_constant", "(", "Pmode", ",", "reg", ",", "base_update", ")", ")", ";", "}", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ";", "}", "</s>" ]

[ "A", "general", "routine", "for", "creating", "the", "body", "RTL", "pattern", "of", "ldwm/stwm/push.n/pop.n", "insns", ".", "LOAD_P", ":", "true/false", "for", "load/store", "direction", ".", "REG_INC_P", ":", "whether", "registers", "are", "incrementing/decrementing", "in", "the", "*", "RTL", "vector", "*", "(", "not", "necessarily", "the", "order", "defined", "in", "the", "ISA", "specification", ")", ".", "OFFSET_INC_P", ":", "Same", "as", "REG_INC_P", ",", "but", "for", "the", "memory", "offset", "order", ".", "BASE_MEM", ":", "starting", "MEM", ".", "BASE_UPDATE", ":", "amount", "to", "update", "base", "register", ";", "zero", "means", "no", "writeback", ".", "REGMASK", ":", "register", "mask", "to", "load/store", ".", "RET_P", ":", "true", "if", "to", "tag", "a", "(", "return", ")", "element", "at", "the", "end", ".", "Note", "that", "this", "routine", "does", "not", "do", "any", "checking", ".", "It", "'s", "the", "job", "of", "the", "caller", "to", "do", "the", "right", "thing", ",", "and", "the", "insn", "patterns", "to", "do", "the", "safe-guarding", "." ]

[ "nios2", "0", "0", "0", "0", "0", "31", "32", "1", "1", "1", "1", "0", "4", "4", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "th_mempair_check_consecutive_mems", "(", "machine_mode", "mode", ",", "rtx", "*", "mem1", ",", "rtx", "*", "mem2", ",", "bool", "*", "reversed", ")", "{", "rtx", "base1", ",", "base2", ",", "offset1", ",", "offset2", ";", "extract_base_offset_in_addr", "(", "*", "mem1", ",", "&", "base1", ",", "&", "offset1", ")", ";", "extract_base_offset_in_addr", "(", "*", "mem2", ",", "&", "base2", ",", "&", "offset2", ")", ";", "if", "(", "!", "base1", "||", "!", "base2", ")", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "base1", ",", "base2", ")", ")", "{", "auto", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "known_eq", "(", "UINTVAL", "(", "offset1", ")", "+", "size", ",", "UINTVAL", "(", "offset2", ")", ")", ")", "{", "*", "reversed", "=", "false", ";", "return", "true", ";", "}", "if", "(", "known_eq", "(", "UINTVAL", "(", "offset2", ")", "+", "size", ",", "UINTVAL", "(", "offset1", ")", ")", ")", "{", "*", "reversed", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Analyse", "if", "a", "pair", "of", "loads/stores", "MEM1", "and", "MEM2", "with", "given", "MODE", "are", "consecutive", "so", "they", "can", "be", "merged", "into", "a", "mempair", "instruction", ".", "RESERVED", "will", "be", "set", "to", "true", ",", "if", "a", "reversal", "of", "the", "accesses", "is", "required", "(", "false", "otherwise", ")", ".", "Returns", "true", "if", "the", "accesses", "can", "be", "merged", "(", "even", "if", "reversing", "is", "necessary", ")", "and", "false", "if", "not", "." ]

[ "riscv" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_INIT_M0", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ".", "getIterator", "(", ")", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "AMDGPU", "::", "M0", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "GET_GROUPSTATICSIZE", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOVK_I32", ")", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "MFI", "->", "LDSSize", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "case", "AMDGPU", "::", "SI_KILL", ":", "return", "splitKillBlock", "(", "MI", ",", "BB", ")", ";", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "}", "return", "BB", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_INIT_M0", "SI", "AMDGPU::S_MOV_B32", "AMDGPU::M0", "0", "AMDGPU::BRANCH", "AMDGPU::GET_GROUPSTATICSIZE", "SI", "SI", "SI", "AMDGPU::S_MOVK_I32", "0", "AMDGPU::SI_KILL", "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "rs6000_savres_routine_sym", "(", "rs6000_stack_t", "*", "info", ",", "int", "sel", ")", "{", "int", "regno", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "info", "->", "first_gp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "info", "->", "first_fp_reg_save", "-", "32", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "info", "->", "first_altivec_reg_save", "-", "FIRST_ALTIVEC_REGNO", ":", "-", "1", ")", ";", "rtx", "sym", ";", "int", "select", "=", "sel", ";", "gcc_assert", "(", "FIRST_SAVRES_REGISTER", "<=", "regno", "&&", "regno", "<=", "LAST_SAVRES_REGISTER", "&&", "select", ">=", "0", "&&", "select", "<=", "12", ")", ";", "sym", "=", "savres_routine_syms", "[", "regno", "-", "FIRST_SAVRES_REGISTER", "]", "[", "select", "]", ";", "if", "(", "sym", "==", "NULL", ")", "{", "char", "*", "name", ";", "name", "=", "rs6000_savres_routine_name", "(", "regno", ",", "sel", ")", ";", "sym", "=", "savres_routine_syms", "[", "regno", "-", "FIRST_SAVRES_REGISTER", "]", "[", "select", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "name", ")", ")", ";", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_FUNCTION", ";", "}", "return", "sym", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "SYMBOL_REF", "for", "an", "out-of-line", "register", "save/restore", "routine", ".", "We", "are", "saving/restoring", "GPRs", "if", "GPR", "is", "true", "." ]

[ "rs6000", "32", "1", "0", "12" ]

[]

[ "<s>", "int", "avr_jump_mode", "(", "rtx", "x", ",", "rtx_insn", "*", "insn", ")", "{", "int", "dest_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "?", "XEXP", "(", "x", ",", "0", ")", ":", "x", ")", ")", ";", "int", "cur_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "jump_distance", "=", "cur_addr", "-", "dest_addr", ";", "if", "(", "-", "63", "<=", "jump_distance", "&&", "jump_distance", "<=", "62", ")", "return", "1", ";", "else", "if", "(", "-", "2046", "<=", "jump_distance", "&&", "jump_distance", "<=", "2045", ")", "return", "2", ";", "else", "if", "(", "AVR_HAVE_JMP_CALL", ")", "return", "3", ";", "return", "2", ";", "}", "</s>" ]

[ "Choose", "mode", "for", "jump", "insn", ":", "1", "-", "relative", "jump", "in", "range", "-63", "<", "=", "x", "<", "=", "62", ";", "2", "-", "relative", "jump", "in", "range", "-2046", "<", "=", "x", "<", "=", "2045", ";", "3", "-", "absolute", "jump", "(", "only", "for", "ATmega", "[", "16", "]", "03", ")", "." ]

[ "avr", "0", "63", "62", "1", "2046", "2045", "2", "3", "2" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createMipsISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "void", "convert_int_to_float128", "(", "rtx", "*", "operands", ",", "enum", "rtx_code", "code", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "tmp", "=", "operands", "[", "2", "]", ";", "rtx", "cvt", ";", "rtvec", "cvt_vec", ";", "rtx", "cvt_unspec", ";", "rtvec", "move_vec", ";", "rtx", "move_unspec", ";", "rtx", "unsigned_flag", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "SCRATCH", ")", "tmp", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "if", "(", "MEM_P", "(", "src", ")", ")", "src", "=", "rs6000_address_for_fpconvert", "(", "src", ")", ";", "if", "(", "GET_MODE", "(", "src", ")", "==", "SImode", ")", "{", "unsigned_flag", "=", "(", "code", "==", "UNSIGNED_FLOAT", ")", "?", "const1_rtx", ":", "const0_rtx", ";", "move_vec", "=", "gen_rtvec", "(", "2", ",", "src", ",", "unsigned_flag", ")", ";", "}", "else", "move_vec", "=", "gen_rtvec", "(", "1", ",", "src", ")", ";", "move_unspec", "=", "gen_rtx_UNSPEC", "(", "V2DImode", ",", "move_vec", ",", "UNSPEC_IEEE128_MOVE", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "move_unspec", ")", ")", ";", "cvt_vec", "=", "gen_rtvec", "(", "1", ",", "tmp", ")", ";", "cvt_unspec", "=", "gen_rtx_UNSPEC", "(", "DImode", ",", "cvt_vec", ",", "UNSPEC_IEEE128_CONVERT", ")", ";", "cvt", "=", "gen_rtx_fmt_e", "(", "code", ",", "GET_MODE", "(", "dest", ")", ",", "cvt_unspec", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "cvt", ")", ")", ";", "}", "</s>" ]

[ "Split", "a", "conversion", "from", "an", "integer", "type", "to", "__float128", "into", "separate", "insns", ".", "OPERANDS", "points", "to", "the", "destination", ",", "source", ",", "and", "V2DI", "temporary", "register", ".", "CODE", "is", "either", "FLOAT", "or", "UNSIGNED_FLOAT", "." ]

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "MCOI", "::", "OPERAND_FIRST_TARGET", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "operandBitWidth", "(", "OperandType", ")", ")", "{", "case", "32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "Trunc", "==", "Imm", "&&", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "64", ":", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "32", "AMDGPU::isInlinableLiteral32", "64", "AMDGPU::isInlinableLiteral64", "16", "16", "16", "AMDGPU::isInlinableLiteral16", "\"invalid bitwidth\"" ]

[]

[ "<s>", "const", "MCExpr", "*", "PPCAIXAsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "CV", ")", ")", "{", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "F", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "F", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "getSectionForFunctionDescriptor", "(", "F", ",", "TM", ")", ")", ";", "return", "MCSymbolRefExpr", "::", "create", "(", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "OutContext", ")", ";", "}", "return", "PPCAsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "LLVM", "Constant", "to", "an", "MCExpr", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "F2003fMCAsmInfo", "::", "isValidUnquotedName", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "Name", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "Name", ".", "size", "(", ")", "==", "2", ")", "{", "if", "(", "Name", "[", "0", "]", "==", "'f'", "&&", "Name", "[", "1", "]", ">=", "'0'", "&&", "Name", "[", "1", "]", "<=", "'7'", ")", "return", "false", ";", "if", "(", "Name", ".", "equals", "(", "\"xx\"", ")", ")", "return", "false", ";", "}", "if", "(", "Name", "[", "0", "]", "==", "'\\''", ")", "{", "return", "false", ";", "}", "bool", "hasNonNumericChar", "=", "false", ";", "for", "(", "char", "C", ":", "Name", ")", "{", "if", "(", "!", "hasNonNumericChar", "&&", "(", "C", "<=", "'0'", "||", "C", ">=", "'9'", ")", ")", "{", "hasNonNumericChar", "=", "true", ";", "}", "if", "(", "!", "isAcceptableChar", "(", "C", ")", ")", "return", "false", ";", "}", "return", "hasNonNumericChar", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "identifier", "Name", "does", "not", "need", "quotes", "to", "be", "syntactically", "correct", "." ]

[ "F2003f", "F2003f", "2", "0", "1", "1", "\"xx\"", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasModifiers", "(", "unsigned", "Opcode", ")", "const", "{", "return", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", "!=", "-", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "has", "any", "modifiers", "." ]

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "void", "s390_expand_split_stack_prologue", "(", "void", ")", "{", "rtx", "r1", ",", "guard", ",", "cc", "=", "NULL", ";", "rtx_insn", "*", "insn", ";", "int", "psso", "=", "TARGET_64BIT", "?", "0x38", ":", "0x20", ";", "HOST_WIDE_INT", "frame_size", "=", "cfun_frame_layout", ".", "frame_size", ";", "HOST_WIDE_INT", "args_size", "=", "crtl", "->", "args", ".", "size", ">=", "0", "?", "(", "(", "crtl", "->", "args", ".", "size", "+", "7", ")", "&", "~", "7", ")", ":", "0", ";", "rtx_code_label", "*", "call_done", "=", "NULL", ";", "rtx_code_label", "*", "parm_base", "=", "NULL", ";", "rtx", "tmp", ";", "gcc_assert", "(", "flag_split_stack", "&&", "reload_completed", ")", ";", "if", "(", "!", "TARGET_CPU_ZARCH", ")", "{", "sorry", "(", "\"CPUs older than z900 are not supported for -fsplit-stack\"", ")", ";", "return", ";", "}", "r1", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "if", "(", "!", "frame_size", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "r1", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "STACK_POINTER_OFFSET", ")", ")", ")", ";", "}", "return", ";", "}", "if", "(", "morestack_ref", "==", "NULL_RTX", ")", "{", "morestack_ref", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__morestack\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "morestack_ref", ")", "|=", "(", "SYMBOL_FLAG_LOCAL", "|", "SYMBOL_FLAG_FUNCTION", ")", ";", "}", "if", "(", "CONST_OK_FOR_K", "(", "frame_size", ")", "||", "CONST_OK_FOR_Op", "(", "frame_size", ")", ")", "{", "emit_move_insn", "(", "r1", ",", "gen_rtx_REG", "(", "Pmode", ",", "TP_REGNUM", ")", ")", ";", "guard", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r1", ",", "psso", ")", ")", ";", "if", "(", "frame_size", ">", "SPLIT_STACK_AVAILABLE", ")", "{", "emit_move_insn", "(", "r1", ",", "guard", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_adddi3", "(", "r1", ",", "r1", ",", "GEN_INT", "(", "frame_size", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "r1", ",", "r1", ",", "GEN_INT", "(", "frame_size", ")", ")", ")", ";", "guard", "=", "r1", ";", "}", "cc", "=", "s390_emit_compare", "(", "LT", ",", "stack_pointer_rtx", ",", "guard", ")", ";", "}", "call_done", "=", "gen_label_rtx", "(", ")", ";", "parm_base", "=", "gen_label_rtx", "(", ")", ";", "tmp", "=", "gen_split_stack_data", "(", "parm_base", ",", "call_done", ",", "GEN_INT", "(", "frame_size", ")", ",", "GEN_INT", "(", "args_size", ")", ")", ";", "insn", "=", "emit_insn", "(", "tmp", ")", ";", "add_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "call_done", ")", ";", "LABEL_NUSES", "(", "call_done", ")", "++", ";", "add_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "parm_base", ")", ";", "LABEL_NUSES", "(", "parm_base", ")", "++", ";", "insn", "=", "emit_move_insn", "(", "r1", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "parm_base", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "parm_base", ")", ";", "LABEL_NUSES", "(", "parm_base", ")", "++", ";", "if", "(", "cc", "!=", "NULL", ")", "{", "tmp", "=", "gen_split_stack_cond_call", "(", "morestack_ref", ",", "cc", ",", "call_done", ")", ";", "insn", "=", "emit_jump_insn", "(", "tmp", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "call_done", ";", "LABEL_NUSES", "(", "call_done", ")", "++", ";", "add_reg_br_prob_note", "(", "insn", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "r1", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "STACK_POINTER_OFFSET", ")", ")", ")", ";", "}", "}", "else", "{", "tmp", "=", "gen_split_stack_call", "(", "morestack_ref", ",", "call_done", ")", ";", "insn", "=", "emit_jump_insn", "(", "tmp", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "call_done", ";", "LABEL_NUSES", "(", "call_done", ")", "++", ";", "emit_barrier", "(", ")", ";", "}", "emit_label", "(", "call_done", ")", ";", "}", "</s>" ]

[ "Emit", "-fsplit-stack", "prologue", ",", "which", "goes", "before", "the", "regular", "function", "prologue", "." ]

[ "s390", "0x38", "0x20", "0", "7", "7", "0", "\"CPUs older than z900 are not supported for -fsplit-stack\"", "1", "\"__morestack\"" ]

[]

[ "<s>", "bool", "CJGFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "CJG", "CJG" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "(", "Kind", "==", "k_Register", ")", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Sparc", "\"Invalid access!\"" ]

[]

[ "<s>", "void", "m68hc11_gen_rotate", "(", "enum", "rtx_code", "code", ",", "rtx", "insn", ",", "rtx", "operands", "[", "]", ")", "{", "int", "val", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", "||", "(", "!", "D_REG_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "DA_REG_P", "(", "operands", "[", "0", "]", ")", ")", ")", "fatal_insn", "(", "\"invalid rotate insn\"", ",", "insn", ")", ";", "val", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "code", "==", "ROTATERT", ")", "val", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "*", "BITS_PER_UNIT", "-", "val", ";", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "!=", "QImode", ")", "CC_STATUS_INIT", ";", "if", "(", "val", ">=", "5", "&&", "val", "<=", "11", ")", "{", "if", "(", "TARGET_M6812", ")", "output_asm_insn", "(", "\"exg\\ta,b\"", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "\"psha\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"tba\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"pulb\"", ",", "operands", ")", ";", "}", "val", "-=", "8", ";", "}", "else", "if", "(", "val", ">=", "12", ")", "{", "val", "=", "val", "-", "16", ";", "}", "if", "(", "val", ">", "0", ")", "{", "while", "(", "--", "val", ">=", "0", ")", "{", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "!=", "QImode", ")", "{", "output_asm_insn", "(", "\"asra\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"rola\"", ",", "operands", ")", ";", "}", "if", "(", "D_REG_P", "(", "operands", "[", "0", "]", ")", ")", "output_asm_insn", "(", "\"rolb\"", ",", "operands", ")", ";", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "!=", "QImode", "||", "DA_REG_P", "(", "operands", "[", "0", "]", ")", ")", "output_asm_insn", "(", "\"rola\"", ",", "operands", ")", ";", "}", "}", "else", "{", "while", "(", "++", "val", "<=", "0", ")", "{", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "!=", "QImode", ")", "output_asm_insn", "(", "\"tap\"", ",", "operands", ")", ";", "if", "(", "D_REG_P", "(", "operands", "[", "0", "]", ")", ")", "output_asm_insn", "(", "\"rorb\"", ",", "operands", ")", ";", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "!=", "QImode", "||", "DA_REG_P", "(", "operands", "[", "0", "]", ")", ")", "output_asm_insn", "(", "\"rora\"", ",", "operands", ")", ";", "}", "}", "}", "</s>" ]

[ "Generate", "the", "code", "for", "a", "ROTATE", "or", "ROTATERT", "on", "a", "QI", "or", "HI", "mode", ".", "The", "source", "and", "destination", "must", "be", "D", "or", "A", "and", "the", "shift", "must", "be", "a", "constant", "." ]

[ "m68hc11", "2", "0", "0", "\"invalid rotate insn\"", "2", "0", "0", "5", "11", "\"exg\\ta,b\"", "\"psha\"", "\"tba\"", "\"pulb\"", "8", "12", "16", "0", "0", "0", "\"asra\"", "\"rola\"", "0", "\"rolb\"", "0", "0", "\"rola\"", "0", "0", "\"tap\"", "0", "\"rorb\"", "0", "0", "\"rora\"" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetInstrInfo", "&", "TII", ",", "DebugLoc", "dl", ",", "const", "ThumbRegisterInfo", "&", "MRI", ",", "int", "NumBytes", ",", "unsigned", "MIFlags", "=", "MachineInstr", "::", "NoFlags", ")", "{", "emitThumbRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "TII", ",", "MRI", ",", "MIFlags", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

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

[]

[ "<s>", "static", "unsigned", "getReturnSaveOffset", "(", "bool", "LP64", ",", "bool", "isMacho", ")", "{", "if", "(", "isMacho", ")", "return", "LP64", "?", "16", ":", "8", ";", "return", "4", ";", "}", "</s>" ]

[ "getReturnSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "return", "address", "." ]

[ "PowerPC", "16", "8", "4" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "alpha_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "8", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", "return", "true", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "LINKAGE_SYMBOL_REF_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "!", "strict", "&&", "NONSTRICT_REG_OK_FP_BASE_P", "(", "x", ")", "&&", "CONST_INT_P", "(", "ofs", ")", ")", "return", "true", ";", "if", "(", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "&&", "CONSTANT_ADDRESS_P", "(", "ofs", ")", ")", "return", "true", ";", "}", "}", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", "{", "if", "(", "small_symbolic_operand", "(", "x", ",", "Pmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", ")", "return", "false", ";", "if", "(", "local_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "dtp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "tp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "legitimate_address_p", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "For", "Alpha", ",", "we", "have", "either", "a", "constant", "address", "or", "the", "sum", "of", "a", "register", "and", "a", "constant", "address", ",", "or", "just", "a", "register", ".", "For", "DImode", ",", "any", "of", "those", "forms", "can", "be", "surrounded", "with", "an", "AND", "that", "clear", "the", "low-order", "three", "bits", ";", "this", "is", "an", "``", "unaligned", "''", "access", "." ]

[ "alpha", "1", "1", "8", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "AArch64PromoteConstant", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "LocalChange", "=", "false", ";", "SmallSet", "<", "Constant", "*", ",", "8", ">", "AlreadyChecked", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "OpIdx", "=", "0", ",", "EndOpIdx", "=", "MI", ".", "getNumOperands", "(", ")", ";", "OpIdx", "!=", "EndOpIdx", ";", "++", "OpIdx", ")", "{", "Constant", "*", "Cst", "=", "dyn_cast", "<", "Constant", ">", "(", "MI", ".", "getOperand", "(", "OpIdx", ")", ")", ";", "if", "(", "Cst", "&&", "!", "isa", "<", "GlobalValue", ">", "(", "Cst", ")", "&&", "!", "isa", "<", "ConstantExpr", ">", "(", "Cst", ")", "&&", "AlreadyChecked", ".", "insert", "(", "Cst", ")", ")", "LocalChange", "|=", "promoteConstant", "(", "Cst", ")", ";", "}", "}", "}", "return", "LocalChange", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "0" ]

[]

[ "<s>", "void", "m32c_output_reg_pop", "(", "FILE", "*", "s", ",", "int", "regno", ")", "{", "if", "(", "regno", "==", "FLG_REGNO", ")", "fprintf", "(", "s", ",", "\"\\tpopc\\tflg\\n\"", ")", ";", "else", "fprintf", "(", "s", ",", "\"\\tpop.%c\\t%s\\n\"", ",", "\" bwll\"", "[", "reg_push_size", "(", "regno", ")", "]", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "</s>" ]

[ "Likewise", "for", "ASM_OUTPUT_REG_POP", "." ]

[ "m32c", "\"\\tpopc\\tflg\\n\"", "\"\\tpop.%c\\t%s\\n\"", "\" bwll\"" ]

[]

[ "<s>", "static", "bool", "v850_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", "||", "(", "(", "regno", "&", "1", ")", "==", "0", "&&", "regno", "!=", "0", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "v850", "4", "1", "0", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "MachineOperand", "&", "BaseOp1", ",", "MachineOperand", "&", "BaseOp2", ",", "unsigned", "NumLoads", ")", "const", "{", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "!", "memOpsHaveSameBasePtr", "(", "FirstLdSt", ",", "BaseOp1", ",", "SecondLdSt", ",", "BaseOp2", ")", ")", "return", "false", ";", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isFLAT", "(", "FirstLdSt", ")", "&&", "isFLAT", "(", "SecondLdSt", ")", ")", ")", "{", "const", "unsigned", "MaxGlobalLoadCluster", "=", "6", ";", "if", "(", "NumLoads", ">", "MaxGlobalLoadCluster", ")", "return", "false", ";", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "!", "FirstDst", ")", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "!", "SecondDst", ")", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "else", "if", "(", "isSMRD", "(", "FirstLdSt", ")", "&&", "isSMRD", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "else", "if", "(", "isDS", "(", "FirstLdSt", ")", "&&", "isDS", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "FirstDst", "->", "getReg", "(", ")", ")", ";", "return", "(", "NumLoads", "*", "(", "RI", ".", "getRegSizeInBits", "(", "*", "DstRC", ")", "/", "8", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "6", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16", "8" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "reduceSelectOfFPConstantLoads", "(", "EVT", "CmpOpVT", ")", "const", "{", "bool", "IsFPSetCC", "=", "CmpOpVT", ".", "isFloatingPoint", "(", ")", "&&", "CmpOpVT", "!=", "MVT", "::", "f128", ";", "return", "!", "IsFPSetCC", "||", "!", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "||", "!", "Subtarget", ".", "hasAVX", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "convert", "a", "select", "of", "FP", "constants", "into", "a", "constant", "pool", "load", "whose", "address", "depends", "on", "the", "select", "condition", "." ]

[ "X86", "X86", "MVT::f128" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getVaListSizeInBits", "(", "const", "DataLayout", "&", "DL", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", "||", "Subtarget", "->", "isTargetWindows", "(", ")", ")", "return", "getPointerTy", "(", "DL", ",", "AS", ")", ".", "getSizeInBits", "(", ")", ";", "return", "3", "*", "getPointerTy", "(", "DL", ",", "AS", ")", ".", "getSizeInBits", "(", ")", "+", "2", "*", "32", ";", "}", "</s>" ]

[ "Returns", "the", "size", "of", "the", "platform", "'s", "va_list", "object", "." ]

[ "AArch64", "AArch64", "3", "2", "32" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "assert", "(", "!", "Val", "==", "VRegs", ".", "empty", "(", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "const", "&", "ST", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "unsigned", "Opcode", "=", "ST", ".", "getReturnOpcode", "(", ")", ";", "auto", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Opcode", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "if", "(", "!", "lowerReturnVal", "(", "MIRBuilder", ",", "Val", ",", "VRegs", ",", "Ret", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "ARM", "ARM", "\"Return value without a vreg\"", "ARM", "ARMCC::AL" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "isIndirectJump", "(", "Inst", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxIndirectJump", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "unsigned", "AddrIdx", ";", "bool", "IsStore", ";", "bool", "IsMemAccess", "=", "isBasePlusOffsetMemoryAccess", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "AddrIdx", ",", "&", "IsStore", ")", ";", "bool", "IsSPFirstOperand", "=", "isStackPointerFirstOperand", "(", "Inst", ")", ";", "if", "(", "IsMemAccess", "||", "IsSPFirstOperand", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "bool", "MaskBefore", "=", "(", "IsMemAccess", "&&", "baseRegNeedsLoadStoreMask", "(", "Inst", ".", "getOperand", "(", "AddrIdx", ")", ".", "getReg", "(", ")", ")", ")", ";", "bool", "MaskAfter", "=", "IsSPFirstOperand", "&&", "!", "IsStore", ";", "if", "(", "MaskBefore", "||", "MaskAfter", ")", "sandboxLoadStoreStackChange", "(", "Inst", ",", "AddrIdx", ",", "STI", ",", "MaskBefore", ",", "MaskAfter", ")", ";", "else", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "bool", "IsIndirectCall", ";", "if", "(", "isCall", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "IsIndirectCall", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "EmitBundleLock", "(", "true", ")", ";", "if", "(", "IsIndirectCall", ")", "{", "unsigned", "TargetReg", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "emitMask", "(", "TargetReg", ",", "IndirectBranchMaskReg", ",", "STI", ")", ";", "}", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "PendingCall", "=", "true", ";", "return", ";", "}", "if", "(", "PendingCall", ")", "{", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "EmitBundleUnlock", "(", ")", ";", "PendingCall", "=", "false", ";", "return", ";", "}", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Mips", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "1" ]

[]

[ "<s>", "bool", "ix86_legitimize_reload_address", "(", "rtx", "x", ",", "machine_mode", ",", "int", "opnum", ",", "int", "type", ",", "int", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", "{", "rtx", "base", ",", "index", ";", "bool", "something_reloaded", "=", "false", ";", "base", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ";", "if", "(", "!", "REG_OK_FOR_BASE_STRICT_P", "(", "base", ")", ")", "{", "push_reload", "(", "base", ",", "NULL_RTX", ",", "&", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "something_reloaded", "=", "true", ";", "}", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "!", "REG_OK_FOR_INDEX_STRICT_P", "(", "index", ")", ")", "{", "push_reload", "(", "index", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "1", ")", ",", "NULL", ",", "INDEX_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "something_reloaded", "=", "true", ";", "}", "gcc_assert", "(", "something_reloaded", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Our", "implementation", "of", "LEGITIMIZE_RELOAD_ADDRESS", ".", "Returns", "a", "value", "to", "replace", "the", "input", "X", ",", "or", "the", "original", "X", "if", "no", "replacement", "is", "called", "for", ".", "The", "output", "parameter", "*", "WIN", "is", "1", "if", "the", "calling", "macro", "should", "goto", "WIN", ",", "0", "if", "it", "should", "not", "." ]

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

[]

[ "<s>", "static", "bool", "loongarch_memmodel_needs_rel_acq_fence", "(", "enum", "memmodel", "model", ")", "{", "switch", "(", "model", ")", "{", "case", "MEMMODEL_ACQ_REL", ":", "case", "MEMMODEL_SEQ_CST", ":", "case", "MEMMODEL_SYNC_SEQ_CST", ":", "case", "MEMMODEL_RELEASE", ":", "case", "MEMMODEL_SYNC_RELEASE", ":", "case", "MEMMODEL_ACQUIRE", ":", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_SYNC_ACQUIRE", ":", "return", "true", ";", "case", "MEMMODEL_RELAXED", ":", "return", "false", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "a", "FENCE", "should", "be", "emitted", "to", "before", "a", "memory", "access", "to", "implement", "the", "release", "portion", "of", "memory", "model", "MODEL", "." ]

[ "loongarch" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "X86", "::", "GR8_NOREXRegClass", ")", "return", "RC", ";", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "X86", "::", "GR8RegClassID", ":", "case", "X86", "::", "GR16RegClassID", ":", "case", "X86", "::", "GR32RegClassID", ":", "case", "X86", "::", "GR64RegClassID", ":", "case", "X86", "::", "FR32RegClassID", ":", "case", "X86", "::", "FR64RegClassID", ":", "case", "X86", "::", "RFP32RegClassID", ":", "case", "X86", "::", "RFP64RegClassID", ":", "case", "X86", "::", "RFP80RegClassID", ":", "case", "X86", "::", "VR128RegClassID", ":", "case", "X86", "::", "VR256RegClassID", ":", "if", "(", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "X86", "X86", "X86::GR8_NOREXRegClass", "X86::GR8RegClassID", "X86::GR16RegClassID", "X86::GR32RegClassID", "X86::GR64RegClassID", "X86::FR32RegClassID", "X86::FR64RegClassID", "X86::RFP32RegClassID", "X86::RFP64RegClassID", "X86::RFP80RegClassID", "X86::VR128RegClassID", "X86::VR256RegClassID" ]

[]

[ "<s>", "void", "mips_order_regs_for_local_alloc", "(", "void", ")", "{", "register", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "reg_alloc_order", "[", "i", "]", "=", "i", ";", "if", "(", "TARGET_MIPS16", ")", "{", "reg_alloc_order", "[", "0", "]", "=", "24", ";", "reg_alloc_order", "[", "24", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "On", "the", "mips16", ",", "we", "want", "to", "allocate", "$", "24", "(", "T_REG", ")", "before", "other", "registers", "for", "instructions", "for", "which", "it", "is", "possible", ".", "This", "helps", "avoid", "shuffling", "registers", "around", "in", "order", "to", "set", "up", "for", "an", "xor", ",", "encouraging", "the", "compiler", "to", "use", "a", "cmp", "instead", "." ]

[ "mips", "0", "0", "24", "24", "0" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"PPC branch conditions have two components!\"", ")", ";", "assert", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "hasISEL", "(", ")", "&&", "\"Cannot insert select on target without ISEL support\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "assert", "(", "RC", "&&", "\"TrueReg and FalseReg must have overlapping register classes\"", ")", ";", "bool", "Is64Bit", "=", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "PPC", "::", "G8RC_NOX0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ";", "assert", "(", "(", "Is64Bit", "||", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "PPC", "::", "GPRC_NOR0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "&&", "\"isel is for regular integer GPRs only\"", ")", ";", "unsigned", "OpCode", "=", "Is64Bit", "?", "PPC", "::", "ISEL8", ":", "PPC", "::", "ISEL", ";", "unsigned", "SelectPred", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "SubIdx", ";", "bool", "SwapOps", ";", "switch", "(", "SelectPred", ")", "{", "default", ":", "llvm_unreachable", "(", "\"invalid predicate for isel\"", ")", ";", "case", "PPC", "::", "PRED_EQ", ":", "SubIdx", "=", "PPC", "::", "sub_eq", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_NE", ":", "SubIdx", "=", "PPC", "::", "sub_eq", ";", "SwapOps", "=", "true", ";", "break", ";", "case", "PPC", "::", "PRED_LT", ":", "SubIdx", "=", "PPC", "::", "sub_lt", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_GE", ":", "SubIdx", "=", "PPC", "::", "sub_lt", ";", "SwapOps", "=", "true", ";", "break", ";", "case", "PPC", "::", "PRED_GT", ":", "SubIdx", "=", "PPC", "::", "sub_gt", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_LE", ":", "SubIdx", "=", "PPC", "::", "sub_gt", ";", "SwapOps", "=", "true", ";", "break", ";", "case", "PPC", "::", "PRED_UN", ":", "SubIdx", "=", "PPC", "::", "sub_un", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_NU", ":", "SubIdx", "=", "PPC", "::", "sub_un", ";", "SwapOps", "=", "true", ";", "break", ";", "}", "unsigned", "FirstReg", "=", "SwapOps", "?", "FalseReg", ":", "TrueReg", ",", "SecondReg", "=", "SwapOps", "?", "TrueReg", ":", "FalseReg", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FirstReg", ")", "->", "contains", "(", "PPC", "::", "R0", ")", "||", "MRI", ".", "getRegClass", "(", "FirstReg", ")", "->", "contains", "(", "PPC", "::", "X0", ")", ")", "{", "const", "TargetRegisterClass", "*", "FirstRC", "=", "MRI", ".", "getRegClass", "(", "FirstReg", ")", "->", "contains", "(", "PPC", "::", "X0", ")", "?", "&", "PPC", "::", "G8RC_NOX0RegClass", ":", "&", "PPC", "::", "GPRC_NOR0RegClass", ";", "unsigned", "OldFirstReg", "=", "FirstReg", ";", "FirstReg", "=", "MRI", ".", "createVirtualRegister", "(", "FirstRC", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "FirstReg", ")", ".", "addReg", "(", "OldFirstReg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "OpCode", ")", ",", "DestReg", ")", ".", "addReg", "(", "FirstReg", ")", ".", "addReg", "(", "SecondReg", ")", ".", "addReg", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ",", "0", ",", "SubIdx", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "PowerPC", "PPC", "2", "\"PPC branch conditions have two components!\"", "\"Cannot insert select on target without ISEL support\"", "\"TrueReg and FalseReg must have overlapping register classes\"", "PPC::G8RCRegClass", "PPC::G8RC_NOX0RegClass", "PPC::GPRCRegClass", "PPC::GPRC_NOR0RegClass", "\"isel is for regular integer GPRs only\"", "PPC::ISEL8", "PPC::ISEL", "0", "\"invalid predicate for isel\"", "PPC::PRED_EQ", "PPC::sub_eq", "PPC::PRED_NE", "PPC::sub_eq", "PPC::PRED_LT", "PPC::sub_lt", "PPC::PRED_GE", "PPC::sub_lt", "PPC::PRED_GT", "PPC::sub_gt", "PPC::PRED_LE", "PPC::sub_gt", "PPC::PRED_UN", "PPC::sub_un", "PPC::PRED_NU", "PPC::sub_un", "PPC::R0", "PPC::X0", "PPC::X0", "PPC::G8RC_NOX0RegClass", "PPC::GPRC_NOR0RegClass", "1", "0" ]

[]

[ "<s>", "bool", "GBZ80AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Error", "=", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "if", "(", "Error", ")", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "GBZ80", "GB" ]

[]

[ "<s>", "static", "unsigned", "int", "s390_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "s390_class_max_nregs", "(", "REGNO_REG_CLASS", "(", "regno", ")", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", ".", "Because", "all", "registers", "in", "a", "class", "have", "the", "same", "size", ",", "this", "is", "equivalent", "to", "CLASS_MAX_NREGS", "." ]

[ "s390" ]

[]

[ "<s>", "static", "int", "s390_adjust_priority", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "int", "priority", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "priority", ";", "if", "(", "s390_tune", "!=", "PROCESSOR_2084_Z990", "&&", "s390_tune", "!=", "PROCESSOR_2094_Z9_109", ")", "return", "priority", ";", "switch", "(", "s390_safe_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_FSTOREDF", ":", "case", "TYPE_FSTORESF", ":", "priority", "=", "priority", "<<", "3", ";", "break", ";", "case", "TYPE_STORE", ":", "case", "TYPE_STM", ":", "priority", "=", "priority", "<<", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "A", "C", "statement", "(", "sans", "semicolon", ")", "to", "update", "the", "integer", "scheduling", "priority", "INSN_PRIORITY", "(", "INSN", ")", ".", "Reduce", "the", "priority", "to", "execute", "the", "INSN", "earlier", ",", "increase", "the", "priority", "to", "execute", "INSN", "later", ".", "Do", "not", "define", "this", "macro", "if", "you", "do", "not", "need", "to", "adjust", "the", "scheduling", "priorities", "of", "insns", ".", "A", "LA", "instruction", "maybe", "scheduled", "later", ",", "since", "the", "pipeline", "bypasses", "the", "calculated", "value", "." ]

[ "s390", "3", "1" ]

[]

[ "<s>", "bool", "ix86_check_movabs", "(", "rtx", "insn", ",", "int", "opnum", ")", "{", "rtx", "set", ",", "mem", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "PARALLEL", ")", "set", "=", "XVECEXP", "(", "set", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "mem", "=", "XEXP", "(", "set", ",", "opnum", ")", ";", "while", "(", "GET_CODE", "(", "mem", ")", "==", "SUBREG", ")", "mem", "=", "SUBREG_REG", "(", "mem", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "return", "volatile_ok", "||", "!", "MEM_VOLATILE_P", "(", "mem", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "OPNUM", "'s", "MEM", "should", "be", "matched", "in", "movabs", "*", "patterns", "." ]

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

[]

[ "<s>", "static", "rtx_insn", "*", "s390_emit_ccraw_jump", "(", "HOST_WIDE_INT", "mask", ",", "enum", "rtx_code", "comparison", ",", "rtx", "label", ")", "{", "rtx", "temp", ";", "gcc_assert", "(", "comparison", "==", "EQ", "||", "comparison", "==", "NE", ")", ";", "gcc_assert", "(", "mask", ">", "0", "&&", "mask", "<", "15", ")", ";", "temp", "=", "gen_rtx_fmt_ee", "(", "comparison", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "CCRAWmode", ",", "CC_REGNUM", ")", ",", "GEN_INT", "(", "mask", ")", ")", ";", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "temp", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "temp", ")", ";", "return", "emit_jump_insn", "(", "temp", ")", ";", "}", "</s>" ]

[ "Emit", "a", "conditional", "jump", "to", "LABEL", "for", "condition", "code", "mask", "MASK", "using", "comparsion", "operator", "COMPARISON", ".", "Return", "the", "emitted", "jump", "insn", "." ]

[ "s390", "0", "15" ]

[]

[ "<s>", "static", "reg_class_t", "frv_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "reload_class_i", ",", "machine_mode", "reload_mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "NO_REGS", ";", "enum", "reg_class", "reload_class", "=", "(", "enum", "reg_class", ")", "reload_class_i", ";", "if", "(", "sri", "->", "prev_sri", "&&", "sri", "->", "prev_sri", "->", "t_icode", "!=", "CODE_FOR_nothing", ")", "{", "sri", "->", "icode", "=", "sri", "->", "prev_sri", "->", "t_icode", ";", "return", "NO_REGS", ";", "}", "rclass", "=", "frv_secondary_reload_class", "(", "reload_class", ",", "reload_mode", ",", "x", ")", ";", "if", "(", "rclass", "!=", "NO_REGS", ")", "{", "enum", "insn_code", "icode", "=", "direct_optab_handler", "(", "in_p", "?", "reload_in_optab", ":", "reload_out_optab", ",", "reload_mode", ")", ";", "if", "(", "icode", "==", "0", ")", "{", "sri", "->", "t_icode", "=", "CODE_FOR_nothing", ";", "return", "rclass", ";", "}", "}", "return", "default_secondary_reload", "(", "in_p", ",", "x", ",", "reload_class", ",", "reload_mode", ",", "sri", ")", ";", "}", "</s>" ]

[ "This", "hook", "exists", "to", "catch", "the", "case", "where", "secondary_reload_class", "(", ")", "is", "called", "from", "init_reg_autoinc", "(", ")", "in", "regclass.c", "-", "before", "the", "reload", "optabs", "have", "been", "initialised", "." ]

[ "frv", "0" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CCAssignFnForCall", "(", "CallConv", ",", "isVarArg", ")", ")", ";", "}", "else", "{", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "Register", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "R600", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Alignment", "=", "MinAlign", "(", "VT", ".", "getStoreSize", "(", ")", ",", "PartOffset", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "AMDGPUAS", "::", "PARAM_I_ADDRESS", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "PartOffset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "Alignment", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "AMDGPU", "R600", "ISD::InputArg", "16", "ISD::InputArg", "8", "AMDGPU::isShader", "0", "ISD::InputArg", "AMDGPU::isShader", "R600::R600_Reg128RegClass", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "AMDGPU", "ISD::UNINDEXED", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "int", "MipsAsmParser", "::", "tryParseRegister", "(", "bool", "is64BitReg", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "int", "RegNum", "=", "-", "1", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "RegNum", "=", "matchRegisterName", "(", "lowerCase", ",", "is64BitReg", ")", ";", "}", "else", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", "RegNum", "=", "matchRegisterByNumber", "(", "static_cast", "<", "unsigned", ">", "(", "Tok", ".", "getIntVal", "(", ")", ")", ",", "is64BitReg", "?", "Mips", "::", "GPR64RegClassID", ":", "Mips", "::", "GPR32RegClassID", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "Mips", "Mips", "1", "Mips::GPR64RegClassID", "Mips::GPR32RegClassID" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"PowerPC QPX Load Splat Simplification\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"PowerPC QPX Load Splat Simplification\"" ]

[]

[ "<s>", "SDValue", "XtensaSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Op1", ",", "SDValue", "Op2", ",", "SDValue", "Op3", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "assert", "(", "false", "&&", "\"XtensaSelectionDAGInfo::EmitTargetCodeForMemcpy\"", "\" not implemented\"", ")", ";", "SDValue", "ret", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaSelectionDAGInfo::EmitTargetCodeForMemcpy\"", "\" not implemented\"" ]

[]

[ "<s>", "static", "int", "cris_reg_saved_in_regsave_area", "(", "unsigned", "int", "regno", ",", "bool", "got_really_used", ")", "{", "return", "(", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "(", "got_really_used", "||", "(", "flag_pic", "&&", "df_regs_ever_live_p", "(", "regno", "+", "1", ")", "&&", "!", "call_used_regs", "[", "regno", "+", "1", "]", ")", ")", ")", ")", "&&", "(", "regno", "!=", "FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "regno", "!=", "CRIS_SRP_REGNUM", ")", "||", "(", "crtl", "->", "calls_eh_return", "&&", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "0", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "1", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "2", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "3", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REGNO", "is", "an", "ordinary", "register", "that", "*", "needs", "*", "to", "be", "saved", "together", "with", "other", "registers", ",", "possibly", "by", "a", "MOVEM", "instruction", ",", "or", "is", "saved", "for", "target-independent", "reasons", ".", "There", "may", "be", "target-dependent", "reasons", "to", "save", "the", "register", "anyway", ";", "this", "is", "just", "a", "wrapper", "for", "a", "complicated", "conditional", "." ]

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

[]

[ "<s>", "bool", "JVMAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", ")", "{", "unsigned", "GPReg", "=", "isN64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "isN64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "if", "(", "Subtarget", "->", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "llvm", "::", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"", "Mips", "\"__Mips16RetHelper\"", "Mips", "Mips" ]

[]

[ "<s>", "static", "int", "microblaze_adjust_cost", "(", "rtx_insn", "*", ",", "int", "dep_type", ",", "rtx_insn", "*", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "if", "(", "dep_type", "==", "REG_DEP_OUTPUT", "||", "dep_type", "==", "0", ")", "return", "cost", ";", "return", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_ADJUST_COST", "." ]

[ "microblaze", "0", "0" ]

[]

[ "<s>", "inline", "void", "function_expander", "::", "add_fixed_operand", "(", "rtx", "x", ")", "{", "create_fixed_operand", "(", "&", "m_ops", "[", "opno", "++", "]", ",", "x", ")", ";", "}", "</s>" ]

[ "Add", "an", "operand", "that", "must", "be", "X", ".", "The", "only", "way", "of", "legitimizing", "an", "invalid", "X", "is", "to", "reload", "the", "address", "of", "a", "MEM", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "bool", "csky_fixed_condition_code_regs", "(", "unsigned", "int", "*", "p1", ",", "unsigned", "int", "*", "p2", ")", "{", "*", "p1", "=", "CSKY_CC_REGNUM", ";", "*", "p2", "=", "INVALID_REGNUM", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_FIXED_CONDITION_CODE_REGS", "." ]

[ "csky" ]

[]

[ "<s>", "static", "void", "frv_align_label", "(", "void", ")", "{", "unsigned", "int", "alignment", ",", "target", ",", "nop", ";", "rtx", "x", ",", "last", ",", "barrier", ",", "label", ";", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "label", "=", "barrier", "=", "0", ";", "alignment", "=", "4", ";", "for", "(", "x", "=", "NEXT_INSN", "(", "last", ")", ";", "x", "!=", "0", "&&", "!", "INSN_P", "(", "x", ")", ";", "x", "=", "NEXT_INSN", "(", "x", ")", ")", "{", "if", "(", "LABEL_P", "(", "x", ")", ")", "{", "unsigned", "int", "subalign", "=", "1", "<<", "label_to_alignment", "(", "x", ")", ";", "alignment", "=", "MAX", "(", "alignment", ",", "subalign", ")", ";", "label", "=", "x", ";", "}", "if", "(", "BARRIER_P", "(", "x", ")", ")", "barrier", "=", "x", ";", "}", "if", "(", "TARGET_ALIGN_LABELS", "&&", "label", "!=", "0", "&&", "barrier", "==", "0", "&&", "frv_packet", ".", "num_insns", "<", "frv_packet", ".", "issue_rate", ")", "alignment", "=", "MAX", "(", "alignment", ",", "8", ")", ";", "frv_packet_address", "+=", "frv_packet", ".", "num_insns", "*", "4", ";", "target", "=", "(", "frv_packet_address", "+", "alignment", "-", "1", ")", "&", "-", "alignment", ";", "if", "(", "barrier", "==", "0", ")", "{", "for", "(", "nop", "=", "0", ";", "nop", "<", "frv_num_nops", ";", "nop", "++", ")", "while", "(", "frv_packet_address", "<", "target", "&&", "frv_pack_insn_p", "(", "frv_nops", "[", "nop", "]", ")", ")", "{", "frv_insert_nop_in_packet", "(", "frv_nops", "[", "nop", "]", ")", ";", "frv_packet_address", "+=", "4", ";", "}", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "nop", "=", "0", ";", "while", "(", "frv_packet_address", "<", "target", ")", "{", "last", "=", "emit_insn_after", "(", "PATTERN", "(", "frv_nops", "[", "nop", "]", ")", ",", "last", ")", ";", "frv_packet_address", "+=", "4", ";", "if", "(", "frv_num_nops", ">", "1", ")", "nop", "^=", "1", ";", "}", "}", "frv_packet_address", "=", "target", ";", "}", "</s>" ]

[ "If", "the", "current", "packet", "falls", "through", "to", "a", "label", ",", "try", "to", "pad", "the", "packet", "with", "nops", "in", "order", "to", "fit", "the", "label", "'s", "alignment", "requirements", "." ]

[ "frv", "1", "0", "4", "0", "1", "0", "0", "8", "4", "1", "0", "0", "4", "1", "0", "4", "1", "1" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "&", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "if", "(", "DefMO", ".", "isReg", "(", ")", "&&", "Register", "::", "isPhysicalRegister", "(", "DefMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "DefMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "DefMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "DefMI", ".", "findRegisterDefOperandIdx", "(", "*", "SR", ",", "false", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "DefIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "const", "MachineOperand", "&", "UseMO", "=", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ";", "if", "(", "UseMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "UseMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "UseMI", ".", "findRegisterUseOperandIdx", "(", "*", "SR", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "UseIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "}", "int", "Latency", "=", "TargetInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "if", "(", "!", "Latency", ")", "Latency", "=", "1", ";", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

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

[]

[ "<s>", "static", "rtx", "expand_msb", "(", "function_expander", "&", "e", ",", "unsigned", "int", "merge_argno", "=", "DEFAULT_MERGE_ARGNO", ")", "{", "if", "(", "e", ".", "pred", "==", "PRED_x", ")", "{", "insn_code", "icode", ";", "if", "(", "e", ".", "type_suffix", "(", "0", ")", ".", "integer_p", ")", "icode", "=", "code_for_aarch64_pred_fnma", "(", "e", ".", "vector_mode", "(", "0", ")", ")", ";", "else", "icode", "=", "code_for_aarch64_pred", "(", "UNSPEC_COND_FMLS", ",", "e", ".", "vector_mode", "(", "0", ")", ")", ";", "return", "e", ".", "use_pred_x_insn", "(", "icode", ")", ";", "}", "insn_code", "icode", "=", "e", ".", "direct_optab_handler", "(", "cond_fnma_optab", ")", ";", "return", "e", ".", "use_cond_insn", "(", "icode", ",", "merge_argno", ")", ";", "}", "</s>" ]

[ "Expand", "a", "call", "to", "svmsb", ",", "or", "svmls", "after", "reordering", "its", "operands", ".", "Make", "_m", "forms", "merge", "with", "argument", "MERGE_ARGNO", "." ]

[ "aarch64", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "rs6000_emit_stack_tie", "(", "rtx", "fp", ",", "bool", "hard_frame_needed", ")", "{", "rtvec", "p", ";", "int", "i", ";", "rtx", "regs", "[", "3", "]", ";", "i", "=", "0", ";", "regs", "[", "i", "++", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "if", "(", "hard_frame_needed", ")", "regs", "[", "i", "++", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "!", "(", "REGNO", "(", "fp", ")", "==", "STACK_POINTER_REGNUM", "||", "(", "hard_frame_needed", "&&", "REGNO", "(", "fp", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", ")", "regs", "[", "i", "++", "]", "=", "fp", ";", "p", "=", "rtvec_alloc", "(", "i", ")", ";", "while", "(", "--", "i", ">=", "0", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "regs", "[", "i", "]", ")", ";", "RTVEC_ELT", "(", "p", ",", "i", ")", "=", "gen_rtx_SET", "(", "mem", ",", "const0_rtx", ")", ";", "}", "emit_insn", "(", "gen_stack_tie", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ")", ";", "}", "</s>" ]

[ "This", "ties", "together", "stack", "memory", "(", "MEM", "with", "an", "alias", "set", "of", "rs6000_sr_alias_set", ")", "and", "the", "change", "to", "the", "stack", "pointer", "." ]

[ "rs6000", "3", "0", "0" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "SNES", "0" ]

[]

[ "<s>", "static", "void", "mmix_file_end", "(", "void", ")", "{", "switch_to_section", "(", "data_section", ")", ";", "}", "</s>" ]

[ "TARGET_ASM_FILE_END", "." ]

[ "mmix" ]

[]

[ "<s>", "bool", "LC2200AsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "LC2200Operand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "continue", ";", "}", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "Error", "(", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"unexpected token in operand list\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "LC2200", "LC2200", "LC2200Operand::CreateToken", "\"unexpected token in operand list\"" ]

[]

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

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "void", "M88kFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "M88kInstrInfo", "&", "LII", "=", "*", "static_cast", "<", "const", "M88kInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "assert", "(", "isInt", "<", "16", ">", "(", "StackSize", ")", "&&", "\"Larger stack frame not yet implemented\"", ")", ";", "unsigned", "MaxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "bool", "SetupFP", "=", "hasFP", "(", "MF", ")", ";", "assert", "(", "(", "SetupFP", "||", "MaxCallFrameSize", "==", "0", ")", "&&", "\"Call frame without FP\"", ")", ";", "assert", "(", "!", "SetupFP", "||", "std", "::", "find_if", "(", "CSI", ".", "begin", "(", ")", ",", "CSI", ".", "end", "(", ")", ",", "[", "]", "(", "const", "CalleeSavedInfo", "&", "CS", ")", "{", "return", "CS", ".", "getReg", "(", ")", "==", "M88k", "::", "R30", ";", "}", ")", "!=", "CSI", ".", "end", "(", ")", "&&", "\"Frame pointer not saved\"", ")", ";", "bool", "SaveRA", "=", "std", "::", "find_if", "(", "CSI", ".", "begin", "(", ")", ",", "CSI", ".", "end", "(", ")", ",", "[", "]", "(", "const", "CalleeSavedInfo", "&", "CS", ")", "{", "return", "CS", ".", "getReg", "(", ")", "==", "M88k", "::", "R1", ";", "}", ")", "!=", "CSI", ".", "end", "(", ")", ";", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "M88k", "::", "SUBUri", ")", ")", ".", "addReg", "(", "M88k", "::", "R31", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "M88k", "::", "R31", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "SaveRA", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "M88k", "::", "STriw", ")", ")", ".", "addReg", "(", "M88k", "::", "R1", ")", ".", "addReg", "(", "M88k", "::", "R31", ")", ".", "addImm", "(", "MaxCallFrameSize", "+", "4", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "SetupFP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "M88k", "::", "STriw", ")", ")", ".", "addReg", "(", "M88k", "::", "R30", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "M88k", "::", "R31", ")", ".", "addImm", "(", "MaxCallFrameSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "M88k", "::", "ADDUri", ")", ")", ".", "addReg", "(", "M88k", "::", "R30", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "M88k", "::", "R31", ")", ".", "addImm", "(", "MaxCallFrameSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "}", "</s>" ]

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

[ "M88k", "M88k", "\"Shrink-wrapping not yet supported\"", "M88k", "M88k", "16", "\"Larger stack frame not yet implemented\"", "0", "\"Call frame without FP\"", "M88k::R30", "\"Frame pointer not saved\"", "M88k::R1", "M88k::SUBUri", "M88k::R31", "M88k::R31", "M88k::STriw", "M88k::R1", "M88k::R31", "4", "M88k::STriw", "M88k::R30", "M88k::R31", "M88k::ADDUri", "M88k::R30", "M88k::R31" ]

[]

[ "<s>", "DEBUG_FUNCTION", "void", "debug_ready_dispatch", "(", "void", ")", "{", "int", "i", ";", "int", "no_ready", "=", "number_in_ready", "(", ")", ";", "fprintf", "(", "stdout", ",", "\"Number of ready: %d\\n\"", ",", "no_ready", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "no_ready", ";", "i", "++", ")", "debug_insn_dispatch_info_file", "(", "stdout", ",", "get_ready_element", "(", "i", ")", ")", ";", "}", "</s>" ]

[ "Print", "to", "STDERR", "the", "status", "of", "the", "ready", "list", "with", "respect", "to", "dispatch", "windows", "." ]

[ "i386", "\"Number of ready: %d\\n\"", "0" ]

[]

[ "<s>", "static", "void", "bpf_option_override", "(", "void", ")", "{", "init_machine_status", "=", "bpf_init_machine_status", ";", "if", "(", "TARGET_BPF_CORE", "&&", "!", "btf_debuginfo_p", "(", ")", ")", "error", "(", "\"BPF CO-RE requires BTF debugging information, use %<-gbtf%>\"", ")", ";", "if", "(", "TARGET_BPF_CORE", ")", "write_symbols", "|=", "BTF_WITH_CORE_DEBUG", ";", "if", "(", "flag_lto", "&&", "TARGET_BPF_CORE", ")", "sorry", "(", "\"BPF CO-RE does not support LTO\"", ")", ";", "if", "(", "btf_debuginfo_p", "(", ")", "&&", "!", "(", "target_flags_explicit", "&", "MASK_BPF_CORE", ")", ")", "{", "target_flags", "|=", "MASK_BPF_CORE", ";", "write_symbols", "|=", "BTF_WITH_CORE_DEBUG", ";", "}", "if", "(", "bpf_has_jmpext", "==", "-", "1", ")", "bpf_has_jmpext", "=", "(", "bpf_isa", ">=", "ISA_V2", ")", ";", "if", "(", "bpf_has_alu32", "==", "-", "1", ")", "bpf_has_alu32", "=", "(", "bpf_isa", ">=", "ISA_V3", ")", ";", "if", "(", "bpf_has_jmp32", "==", "-", "1", ")", "bpf_has_jmp32", "=", "(", "bpf_isa", ">=", "ISA_V3", ")", ";", "}", "</s>" ]

[ "Override", "options", "and", "do", "some", "other", "initialization", "." ]

[ "bpf", "\"BPF CO-RE requires BTF debugging information, use %<-gbtf%>\"", "\"BPF CO-RE does not support LTO\"", "1", "1", "1" ]

[]

[ "<s>", "bool", "TL45InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "}", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "TL45", "TL45" ]

[]

[ "<s>", "void", "ix86_fp_comparison_codes", "(", "enum", "rtx_code", "code", ",", "enum", "rtx_code", "*", "bypass_code", ",", "enum", "rtx_code", "*", "first_code", ",", "enum", "rtx_code", "*", "second_code", ")", "{", "*", "first_code", "=", "code", ";", "*", "bypass_code", "=", "UNKNOWN", ";", "*", "second_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GE", ":", "case", "ORDERED", ":", "case", "UNORDERED", ":", "case", "UNEQ", ":", "case", "UNLT", ":", "case", "UNLE", ":", "case", "LTGT", ":", "break", ";", "case", "LT", ":", "*", "first_code", "=", "UNLT", ";", "*", "bypass_code", "=", "UNORDERED", ";", "break", ";", "case", "LE", ":", "*", "first_code", "=", "UNLE", ";", "*", "bypass_code", "=", "UNORDERED", ";", "break", ";", "case", "EQ", ":", "*", "first_code", "=", "UNEQ", ";", "*", "bypass_code", "=", "UNORDERED", ";", "break", ";", "case", "NE", ":", "*", "first_code", "=", "LTGT", ";", "*", "second_code", "=", "UNORDERED", ";", "break", ";", "case", "UNGE", ":", "*", "first_code", "=", "GE", ";", "*", "second_code", "=", "UNORDERED", ";", "break", ";", "case", "UNGT", ":", "*", "first_code", "=", "GT", ";", "*", "second_code", "=", "UNORDERED", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "TARGET_IEEE_FP", ")", "{", "*", "second_code", "=", "UNKNOWN", ";", "*", "bypass_code", "=", "UNKNOWN", ";", "}", "}", "</s>" ]

[ "Split", "comparison", "code", "CODE", "into", "comparisons", "we", "can", "do", "using", "branch", "instructions", ".", "BYPASS_CODE", "is", "comparison", "code", "for", "branch", "that", "will", "branch", "around", "FIRST_CODE", "and", "SECOND_CODE", ".", "If", "some", "of", "branches", "is", "not", "required", ",", "set", "value", "to", "UNKNOWN", ".", "We", "never", "require", "more", "than", "two", "branches", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "s390_add_execute", "(", "struct", "constant_pool", "*", "pool", ",", "rtx", "insn", ")", "{", "struct", "constant", "*", "c", ";", "for", "(", "c", "=", "pool", "->", "execute", ";", "c", "!=", "NULL", ";", "c", "=", "c", "->", "next", ")", "if", "(", "INSN_UID", "(", "insn", ")", "==", "INSN_UID", "(", "c", "->", "value", ")", ")", "break", ";", "if", "(", "c", "==", "NULL", ")", "{", "c", "=", "(", "struct", "constant", "*", ")", "xmalloc", "(", "sizeof", "*", "c", ")", ";", "c", "->", "value", "=", "insn", ";", "c", "->", "label", "=", "gen_label_rtx", "(", ")", ";", "c", "->", "next", "=", "pool", "->", "execute", ";", "pool", "->", "execute", "=", "c", ";", "pool", "->", "size", "+=", "6", ";", "}", "}", "</s>" ]

[ "Add", "execute", "target", "for", "INSN", "to", "the", "constant", "pool", "POOL", "." ]

[ "s390", "6" ]

[]

[ "<s>", "bool", "GCNRegBankReassign", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasRegisterBanking", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "VRM", "=", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ";", "LRM", "=", "&", "getAnalysis", "<", "LiveRegMatrix", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "MFI", "->", "getOccupancy", "(", ")", ";", "MaxNumVGPRs", "=", "ST", "->", "getMaxNumVGPRs", "(", "MF", ")", ";", "MaxNumSGPRs", "=", "ST", "->", "getMaxNumSGPRs", "(", "MF", ")", ";", "MaxNumVGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "MaxNumVGPRs", ")", ";", "MaxNumSGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "MaxNumSGPRs", ")", ";", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "RegsUsed", ".", "resize", "(", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", "+", "TRI", "->", "getEncodingValue", "(", "AMDGPU", "::", "SGPR_NULL", ")", "/", "2", "+", "1", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== RegBanks reassign analysis on function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "unsigned", "StallCycles", "=", "collectCandidates", "(", "MF", ")", ";", "NumStallsDetected", "+=", "StallCycles", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== \"", "<<", "StallCycles", "<<", "\" stall cycles detected in \"", "\"function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "sort", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "C", ":", "Candidates", ")", "C", ".", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "unsigned", "CyclesSaved", "=", "0", ";", "while", "(", "!", "Candidates", ".", "empty", "(", ")", ")", "{", "Candidate", "C", "=", "Candidates", ".", "back", "(", ")", ";", "unsigned", "LocalCyclesSaved", "=", "tryReassign", "(", "C", ")", ";", "CyclesSaved", "+=", "LocalCyclesSaved", ";", "if", "(", "VerifyStallCycles", ">", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "Candidates", ".", "pop_back", "(", ")", ";", "if", "(", "LocalCyclesSaved", ")", "{", "removeCandidates", "(", "C", ".", "Reg", ")", ";", "computeStallCycles", "(", "C", ".", "Reg", ",", "AMDGPU", "::", "NoRegister", ",", "-", "1", ",", "true", ")", ";", "Candidates", ".", "sort", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "C", ":", "Candidates", ")", "C", ".", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "}", "}", "NumStallsRecovered", "+=", "CyclesSaved", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== After the pass \"", "<<", "CyclesSaved", "<<", "\" cycles saved in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "clear", "(", ")", ";", "if", "(", "VerifyStallCycles", "==", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "RegsUsed", ".", "clear", "(", ")", ";", "return", "CyclesSaved", ">", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_NULL", "2", "1", "\"=== RegBanks reassign analysis on function \"", "\"=== \"", "\" stall cycles detected in \"", "\"function \"", "\"\\nCandidates:\\n\\n\"", "\"\\n\\n\"", "0", "1", "\"RegBank reassign stall cycles verification failed.\"", "AMDGPU::NoRegister", "1", "\"\\nCandidates:\\n\\n\"", "\"\\n\\n\"", "\"=== After the pass \"", "\" cycles saved in function \"", "1", "\"RegBank reassign stall cycles verification failed.\"", "0" ]

[]

[ "<s>", "bool", "getAlign", "(", "const", "CallInst", "&", "I", ",", "unsigned", "index", ",", "unsigned", "&", "align", ")", "{", "if", "(", "MDNode", "*", "alignNode", "=", "I", ".", "getMetadata", "(", "\"callalign\"", ")", ")", "{", "for", "(", "int", "i", "=", "0", ",", "n", "=", "alignNode", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "mdconst", "::", "dyn_extract", "<", "ConstantInt", ">", "(", "alignNode", "->", "getOperand", "(", "i", ")", ")", ")", "{", "unsigned", "v", "=", "CI", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "v", ">>", "16", ")", "==", "index", ")", "{", "align", "=", "v", "&", "0xFFFF", ";", "return", "true", ";", "}", "if", "(", "(", "v", ">>", "16", ")", ">", "index", ")", "{", "return", "false", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "the", "minimum", "known", "alignment", "in", "bytes", "of", "the", "actual", "memory", "reference", "." ]

[ "NVPTX", "\"callalign\"", "0", "16", "0xFFFF", "16" ]

[]

[ "<s>", "void", "FISCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "FISC", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::STR", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "static", "void", "pa_hpux_file_end", "(", "void", ")", "{", "unsigned", "int", "i", ";", "extern_symbol", "*", "p", ";", "if", "(", "!", "NO_DEFERRED_PROFILE_COUNTERS", ")", "output_deferred_profile_counters", "(", ")", ";", "output_deferred_plabels", "(", ")", ";", "for", "(", "i", "=", "0", ";", "vec_safe_iterate", "(", "extern_symbols", ",", "i", ",", "&", "p", ")", ";", "i", "++", ")", "{", "tree", "decl", "=", "p", "->", "decl", ";", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", "&&", "SYMBOL_REF_REFERENCED_P", "(", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ")", ")", "ASM_OUTPUT_EXTERNAL_REAL", "(", "asm_out_file", ",", "decl", ",", "p", "->", "name", ")", ";", "}", "vec_free", "(", "extern_symbols", ")", ";", "}", "</s>" ]

[ "Output", "text", "required", "at", "the", "end", "of", "an", "assembler", "file", ".", "This", "includes", "deferred", "plabels", "and", ".import", "directives", "for", "all", "external", "symbols", "that", "were", "actually", "referenced", "." ]

[ "pa", "0", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MVT", "VT", "=", "Outs", "[", "i", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "if", "(", "CC_RISCV", "(", "MF", ".", "getDataLayout", "(", ")", ",", "i", ",", "VT", ",", "VT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "CCInfo", ",", "true", ",", "true", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "RISCV", "RISCV", "ISD::OutputArg", "16", "0", "ISD::ArgFlagsTy", "RISCV" ]

[]

[ "<s>", "static", "int", "vfp3_const_double_index", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "m", ";", "int", "sign", ",", "exponent", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mant_hi", ";", "unsigned", "HOST_WIDE_INT", "mask", ";", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "bool", "fail", ";", "if", "(", "!", "TARGET_VFP3", "||", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "-", "1", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ")", "return", "-", "1", ";", "sign", "=", "REAL_VALUE_NEGATIVE", "(", "r", ")", "?", "1", ":", "0", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "mantissa", "=", "w", ".", "elt", "(", "0", ")", ";", "mant_hi", "=", "w", ".", "elt", "(", "1", ")", ";", "if", "(", "mantissa", "!=", "0", ")", "return", "-", "1", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mantissa", "=", "mant_hi", ";", "mask", "=", "(", "HOST_WIDE_INT_1U", "<<", "(", "point_pos", "-", "5", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "-", "1", ";", "mantissa", ">>=", "point_pos", "-", "5", ";", "if", "(", "mantissa", "==", "0", ")", "return", "-", "1", ";", "gcc_assert", "(", "mantissa", ">=", "16", "&&", "mantissa", "<=", "31", ")", ";", "exponent", "=", "5", "-", "exponent", ";", "if", "(", "exponent", "<", "0", "||", "exponent", ">", "7", ")", "return", "-", "1", ";", "return", "(", "sign", "<<", "7", ")", "|", "(", "(", "exponent", "^", "3", ")", "<<", "4", ")", "|", "(", "mantissa", "-", "16", ")", ";", "}", "</s>" ]

[ "Return", "an", "integer", "index", "for", "a", "VFPv3", "immediate", "operand", "X", "suitable", "for", "the", "fconst", "[", "sd", "]", "instruction", ",", "or", "-1", "if", "X", "is", "n't", "suitable", "." ]

[ "arm", "2", "1", "1", "1", "1", "0", "2", "0", "1", "0", "1", "5", "1", "0", "1", "5", "0", "1", "16", "31", "5", "0", "7", "1", "7", "3", "4", "16" ]

[]

[ "<s>", "bool", "LC2200AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "AMDGPU", "::", "EXEC", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "LLVM_DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "0", "AMDGPU::EXEC", "AMDGPU::SReg_64RegClass", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::S_WQM_B64", "AMDGPU::EXEC", "AMDGPU::EXEC", "AMDGPU::SCC" ]

[]

[ "<s>", "const", "NVPTXInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "int", "s390_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "reg_size", ";", "bool", "reg_pair_required_p", "=", "false", ";", "switch", "(", "rclass", ")", "{", "case", "FP_REGS", ":", "case", "VEC_REGS", ":", "reg_size", "=", "TARGET_VX", "?", "16", ":", "8", ";", "if", "(", "TARGET_VX", "&&", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">=", "16", "&&", "!", "(", "TARGET_VXE", "&&", "mode", "==", "TFmode", ")", ")", "reg_pair_required_p", "=", "true", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "reg_pair_required_p", "=", "true", ";", "break", ";", "case", "ACCESS_REGS", ":", "reg_size", "=", "4", ";", "break", ";", "default", ":", "reg_size", "=", "UNITS_PER_WORD", ";", "break", ";", "}", "if", "(", "reg_pair_required_p", ")", "return", "2", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", "+", "reg_size", "-", "1", ")", "/", "reg_size", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "reg_size", "-", "1", ")", "/", "reg_size", ";", "}", "</s>" ]

[ "Maximum", "number", "of", "registers", "to", "represent", "a", "value", "of", "mode", "MODE", "in", "a", "register", "of", "class", "RCLASS", "." ]

[ "s390", "16", "8", "16", "4", "2", "2", "1", "1" ]

[]

[ "<s>", "static", "void", "rs6000_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "cfun", "->", "is_thunk", ")", "rs6000_output_savres_externs", "(", "file", ")", ";", "if", "(", "rs6000_global_entry_point_needed_p", "(", ")", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "file", ",", "\"LCF\"", ",", "rs6000_pic_labelno", ")", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_LARGE", ")", "{", "char", "buf", "[", "256", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCF\"", ",", "rs6000_pic_labelno", ")", ";", "fprintf", "(", "file", ",", "\"0:\\taddis 2,12,.TOC.-\"", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"@ha\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\taddi 2,2,.TOC.-\"", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"@l\\n\"", ")", ";", "}", "else", "{", "char", "buf", "[", "256", "]", ";", "fprintf", "(", "file", ",", "\"\\t.reloc .,R_PPC64_ENTRY\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tld 2,\"", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCL\"", ",", "rs6000_pic_labelno", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCF\"", ",", "rs6000_pic_labelno", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"(12)\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tadd 2,2,12\\n\"", ")", ";", "}", "fputs", "(", "\"\\t.localentry\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fputs", "(", "\",.-\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "}", "if", "(", "TARGET_PROFILE_KERNEL", "&&", "crtl", "->", "profile", ")", "{", "gcc_assert", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", ";", "gcc_assert", "(", "!", "TARGET_32BIT", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tmflr %s\\n\"", ",", "reg_names", "[", "0", "]", ")", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_ELFv2", "&&", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tstd %s,24(%s)\\n\"", ",", "reg_names", "[", "STATIC_CHAIN_REGNUM", "]", ",", "reg_names", "[", "1", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\tbl %s\\n\"", ",", "RS6000_MCOUNT", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tld %s,24(%s)\\n\"", ",", "reg_names", "[", "STATIC_CHAIN_REGNUM", "]", ",", "reg_names", "[", "1", "]", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"\\tbl %s\\n\"", ",", "RS6000_MCOUNT", ")", ";", "}", "rs6000_pic_labelno", "++", ";", "}", "</s>" ]

[ "Write", "function", "prologue", "." ]

[ "rs6000", "0", "0", "\"LCF\"", "256", "\"LCF\"", "\"0:\\taddis 2,12,.TOC.-\"", "\"@ha\\n\"", "\"\\taddi 2,2,.TOC.-\"", "\"@l\\n\"", "256", "\"\\t.reloc .,R_PPC64_ENTRY\\n\"", "\"\\tld 2,\"", "\"LCL\"", "\"-\"", "\"LCF\"", "\"(12)\\n\"", "\"\\tadd 2,2,12\\n\"", "\"\\t.localentry\\t\"", "\",.-\"", "\"\\n\"", "\"\\tmflr %s\\n\"", "0", "\"\\tstd %s,24(%s)\\n\"", "1", "\"\\tbl %s\\n\"", "\"\\tld %s,24(%s)\\n\"", "1", "\"\\tbl %s\\n\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Lower Emscripten Exceptions\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Lower Emscripten Exceptions\"" ]

[]

[ "<s>", "unsigned", "Z80RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "return", "3", ";", "const", "Z80FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "Z80", "::", "R16RegClassID", ":", "case", "Z80", "::", "R24RegClassID", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "Z80", "Z80", "3", "Z80", "0", "Z80::R16RegClassID", "Z80::R24RegClassID", "2" ]

[]

[ "<s>", "bool", "RV16KDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_i", ":", "llvm_unreachable", "(", "\"\"", ")", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "\"\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SHUFPS", ":", "case", "X86ISD", "::", "SHUFPD", ":", "case", "X86ISD", "::", "PUNPCKHBW", ":", "case", "X86ISD", "::", "PUNPCKHWD", ":", "case", "X86ISD", "::", "PUNPCKHDQ", ":", "case", "X86ISD", "::", "PUNPCKHQDQ", ":", "case", "X86ISD", "::", "UNPCKHPS", ":", "case", "X86ISD", "::", "UNPCKHPD", ":", "case", "X86ISD", "::", "PUNPCKLBW", ":", "case", "X86ISD", "::", "PUNPCKLWD", ":", "case", "X86ISD", "::", "PUNPCKLDQ", ":", "case", "X86ISD", "::", "PUNPCKLQDQ", ":", "case", "X86ISD", "::", "UNPCKLPS", ":", "case", "X86ISD", "::", "UNPCKLPD", ":", "case", "X86ISD", "::", "MOVHLPS", ":", "case", "X86ISD", "::", "MOVLHPS", ":", "case", "X86ISD", "::", "PSHUFD", ":", "case", "X86ISD", "::", "PSHUFHW", ":", "case", "X86ISD", "::", "PSHUFLW", ":", "case", "X86ISD", "::", "MOVSS", ":", "case", "X86ISD", "::", "MOVSD", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</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", "." ]

[ "X86", "X86", "ISD::EXTRACT_VECTOR_ELT", "ISD::SELECT", "X86ISD::CMOV", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::OR", "ISD::STORE", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::ZERO_EXTEND", "X86ISD::SHUFPS", "X86ISD::SHUFPD", "X86ISD::PUNPCKHBW", "X86ISD::PUNPCKHWD", "X86ISD::PUNPCKHDQ", "X86ISD::PUNPCKHQDQ", "X86ISD::UNPCKHPS", "X86ISD::UNPCKHPD", "X86ISD::PUNPCKLBW", "X86ISD::PUNPCKLWD", "X86ISD::PUNPCKLDQ", "X86ISD::PUNPCKLQDQ", "X86ISD::UNPCKLPS", "X86ISD::UNPCKLPD", "X86ISD::MOVHLPS", "X86ISD::MOVLHPS", "X86ISD::PSHUFD", "X86ISD::PSHUFHW", "X86ISD::PSHUFLW", "X86ISD::MOVSS", "X86ISD::MOVSD", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "Wasm", ")", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMemIntrinsicResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyDebugFixup", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

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

[ "isVarArg", "-", "Return", "true", "if", "this", "function", "takes", "a", "variable", "number", "of", "arguments", "." ]

[ "Hexagon" ]

[]

[ "<s>", "Register", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "Hexagon", "::", "R1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "Hexagon", "Hexagon::R1" ]

[]

[ "<s>", "bool", "X86LoadValueInjectionRetHardeningPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" *****\\n\"", ")", ";", "const", "X86Subtarget", "*", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "useLVIControlFlowIntegrity", "(", ")", "||", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "false", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasOptNone", "(", ")", "&&", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "++", "NumFunctionsConsidered", ";", "const", "X86RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MBBI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MBBI", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "!=", "X86", "::", "RET64", ")", "continue", ";", "unsigned", "ClobberReg", "=", "TRI", "->", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ")", ";", "if", "(", "ClobberReg", "!=", "X86", "::", "NoRegister", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "POP64r", ")", ")", ".", "addReg", "(", "ClobberReg", ",", "RegState", "::", "Define", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "JMP64r", ")", ")", ".", "addReg", "(", "ClobberReg", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "MachineInstr", "*", "Fence", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "Fence", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "SHL64mi", ")", ")", ",", "X86", "::", "RSP", ",", "false", ",", "0", ")", ".", "addImm", "(", "0", ")", "->", "addRegisterDead", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ";", "}", "++", "NumFences", ";", "Modified", "=", "true", ";", "break", ";", "}", "}", "if", "(", "Modified", ")", "++", "NumFunctionsMitigated", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"***** \"", "\" : \"", "\" *****\\n\"", "X86", "X86", "X86", "X86", "X86::RET64", "X86::NoRegister", "X86::POP64r", "X86::LFENCE", "X86::JMP64r", "X86::LFENCE", "X86::SHL64mi", "X86::RSP", "0", "0", "X86::EFLAGS" ]

[]