Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "OR1K", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "OR1K", "OR1K::NumTargetFixupKinds" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameStoreOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasStoreToStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "DFAPacketizer", "*", "HexagonInstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "TM", "->", "getSubtarget", "<", "HexagonGenSubtargetInfo", ">", "(", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

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

[]

[ "<s>", "static", "bool", "mips_mult_move_p", "(", "rtx", "dest", ",", "rtx", "src", ",", "enum", "mips_split_type", "split_type", ")", "{", "return", "(", "(", "split_type", "!=", "SPLIT_FOR_SPEED", "||", "mips_tuning_info", ".", "fast_mult_zero_zero_p", ")", "&&", "src", "==", "const0_rtx", "&&", "REG_P", "(", "dest", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", "==", "2", "*", "UNITS_PER_WORD", "&&", "(", "ISA_HAS_DSP_MULT", "?", "ACC_REG_P", "(", "REGNO", "(", "dest", ")", ")", ":", "MD_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SRC", "should", "be", "moved", "into", "DEST", "using", "``", "MULT", "$", "0", ",", "$", "0", "''", ".", "SPLIT_TYPE", "is", "the", "condition", "under", "which", "moves", "should", "be", "split", "." ]

[ "mips", "2" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "I", "->", "getNumUses", "(", ")", "!=", "1", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "if", "(", "User", "&&", "!", "(", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FSub", "||", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FAdd", ")", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "const", "DataLayout", "&", "DL", "=", "I", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "EVT", "VT", "=", "getValueType", "(", "DL", ",", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "return", "!", "(", "isFMAFasterThanFMulAndFAdd", "(", "VT", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "VT", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "AArch64", "AArch64", "1", "0", "ISD::FMA" ]

[]

[ "<s>", "static", "rtx", "ft32_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "*", "cum", "<", "8", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "*", "cum", ")", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "the", "next", "register", "to", "be", "used", "to", "hold", "a", "function", "argument", "or", "NULL_RTX", "if", "there", "'s", "no", "more", "space", "." ]

[ "ft32", "8" ]

[]

[ "<s>", "void", "AMDGPUTargetELFStreamer", "::", "finish", "(", ")", "{", "std", "::", "string", "Blob", ";", "const", "char", "*", "Vendor", "=", "getPALMetadata", "(", ")", "->", "getVendor", "(", ")", ";", "unsigned", "Type", "=", "getPALMetadata", "(", ")", "->", "getType", "(", ")", ";", "getPALMetadata", "(", ")", "->", "toBlob", "(", "Type", ",", "Blob", ")", ";", "if", "(", "Blob", ".", "empty", "(", ")", ")", "return", ";", "EmitNote", "(", "Vendor", ",", "MCConstantExpr", "::", "create", "(", "Blob", ".", "size", "(", ")", ",", "getContext", "(", ")", ")", ",", "Type", ",", "[", "&", "]", "(", "MCELFStreamer", "&", "OS", ")", "{", "OS", ".", "emitBytes", "(", "Blob", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "MachinePointerInfo", "MipsFunctionInfo", "::", "callPtrInfo", "(", "const", "GlobalValue", "*", "Val", ")", "{", "std", "::", "unique_ptr", "<", "const", "MipsCallEntry", ">", "&", "E", "=", "GlobalCallEntries", "[", "Val", "]", ";", "if", "(", "!", "E", ")", "E", "=", "llvm", "::", "make_unique", "<", "MipsCallEntry", ">", "(", "Val", ")", ";", "return", "MachinePointerInfo", "(", "E", ".", "get", "(", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "MachinePointerInfo", "that", "has", "a", "GlobalValuePseudoSourceValue", "object", "representing", "a", "GOT", "entry", "for", "a", "global", "function", "." ]

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

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "NumBytes", "+=", "92", ";", "NumBytes", "=", "(", "NumBytes", "+", "7", ")", "&", "~", "7", ";", "NumBytes", "=", "-", "NumBytes", ";", "if", "(", "NumBytes", ">=", "-", "4096", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SAVEri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "NumBytes", ">>", "10U", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ORri", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addImm", "(", "NumBytes", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SAVErr", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "92", "7", "7", "4096", "SP::SAVEri", "SP::O6", "SP::O6", "10U", "SP::SETHIi", "SP::G1", "SP::ORri", "SP::G1", "SP::G1", "1", "10", "1", "SP::SAVErr", "SP::O6", "SP::O6", "SP::G1" ]

[]

[ "<s>", "static", "bool", "needs_frame_header_p", "(", "function", "*", "fn", ")", "{", "tree", "t", ";", "if", "(", "fn", "->", "decl", "==", "NULL", ")", "return", "true", ";", "if", "(", "fn", "->", "stdarg", ")", "return", "true", ";", "for", "(", "t", "=", "DECL_ARGUMENTS", "(", "fn", "->", "decl", ")", ";", "t", ";", "t", "=", "TREE_CHAIN", "(", "t", ")", ")", "{", "if", "(", "!", "use_register_for_decl", "(", "t", ")", ")", "return", "true", ";", "if", "(", "DECL_MODE", "(", "t", ")", "!=", "SImode", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "function", "will", "use", "the", "stack", "space", "allocated", "by", "its", "caller", "or", "if", "we", "can", "not", "determine", "for", "certain", "that", "it", "does", "not", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "const", "MachineOperand", "&", "Offset", "=", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ";", "if", "(", "Base", ".", "isReg", "(", ")", ")", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "else", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "if", "(", "Offset", ".", "isImm", "(", ")", ")", "{", "if", "(", "Offset", ".", "getImm", "(", ")", ")", "O", "<<", "\" + #\"", "<<", "Offset", ".", "getImm", "(", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "1", "\"Unimplemented\"", "\" + #\"", "\"Unimplemented\"" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_cmov", "(", "rtx", "operands", "[", "]", ",", "int", "cmp_t", ",", "const", "char", "*", "test", ")", "{", "int", "load_value", ";", "int", "adjust_value", ";", "rtx", "out_operands", "[", "4", "]", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "if", "(", "const_ok_for_mcore", "(", "INTVAL", "(", "operands", "[", "1", "]", ")", ")", ")", "{", "out_operands", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "out_operands", "[", "2", "]", "=", "operands", "[", "2", "]", ";", "}", "else", "if", "(", "const_ok_for_mcore", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ")", "{", "out_operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "out_operands", "[", "2", "]", "=", "operands", "[", "1", "]", ";", "cmp_t", "=", "(", "cmp_t", "==", "0", ")", ";", "}", "load_value", "=", "INTVAL", "(", "out_operands", "[", "1", "]", ")", ";", "adjust_value", "=", "INTVAL", "(", "out_operands", "[", "2", "]", ")", ";", "if", "(", "test", ")", "output_asm_insn", "(", "test", ",", "operands", ")", ";", "if", "(", "load_value", ">=", "0", "&&", "load_value", "<=", "127", ")", "output_asm_insn", "(", "\"movi\\t%0,%1\"", ",", "out_operands", ")", ";", "else", "if", "(", "(", "load_value", "&", "(", "load_value", "-", "1", ")", ")", "==", "0", ")", "output_asm_insn", "(", "\"bgeni\\t%0,%P1\"", ",", "out_operands", ")", ";", "else", "if", "(", "(", "load_value", "&", "(", "load_value", "+", "1", ")", ")", "==", "0", ")", "output_asm_insn", "(", "\"bmaski\\t%0,%N1\"", ",", "out_operands", ")", ";", "if", "(", "load_value", ">", "adjust_value", ")", "{", "if", "(", "cmp_t", ")", "output_asm_insn", "(", "\"decf\\t%0\"", ",", "out_operands", ")", ";", "else", "output_asm_insn", "(", "\"dect\\t%0\"", ",", "out_operands", ")", ";", "}", "else", "{", "if", "(", "cmp_t", ")", "output_asm_insn", "(", "\"incf\\t%0\"", ",", "out_operands", ")", ";", "else", "output_asm_insn", "(", "\"inct\\t%0\"", ",", "out_operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "conditional", "move", "of", "two", "constants", "that", "are", "+/-", "1", "within", "each", "other", ".", "See", "the", "``", "movtK", "''", "patterns", "in", "mcore.md", ".", "I", "'m", "not", "sure", "this", "is", "really", "worth", "the", "effort", "." ]

[ "mcore", "4", "0", "0", "1", "1", "1", "2", "2", "2", "1", "2", "2", "1", "0", "1", "2", "0", "127", "\"movi\\t%0,%1\"", "1", "0", "\"bgeni\\t%0,%P1\"", "1", "0", "\"bmaski\\t%0,%N1\"", "\"decf\\t%0\"", "\"dect\\t%0\"", "\"incf\\t%0\"", "\"inct\\t%0\"", "\"\"" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", "&&", "!", "TII", "->", "isGather4", "(", "Opcode", ")", ")", "{", "return", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "}", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_DIV_SCALE_F32", ":", "case", "AMDGPU", "::", "V_DIV_SCALE_F64", ":", "{", "SDValue", "Src0", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Src1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ",", "Src0", ".", "getNode", "(", ")", "->", "isDivergent", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "Ops", "=", "{", "Src0", ",", "Src1", ",", "Src2", "}", ";", "for", "(", "unsigned", "I", "=", "3", ",", "N", "=", "Node", "->", "getNumOperands", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "I", ")", ")", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "1", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";", "}", "default", ":", "break", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE", "AMDGPU::V_DIV_SCALE_F32", "AMDGPU::V_DIV_SCALE_F64", "0", "1", "2", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "4", "3", "1" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", "&&", "IsCallReloc", ")", "{", "unsigned", "GPReg", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "ABI", ".", "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", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "DAG", ".", "getMachineFunction", "(", ")", ",", "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>", "FastISel", "*", "ARM64TargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "return", "ARM64", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "ARM64", "ARM64", "ARM64::createFastISel" ]

[]

[ "<s>", "static", "int", "pdp11_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "c1", ",", "reg_class_t", "c2", ")", "{", "if", "(", "CPU_REG_CLASS", "(", "c1", ")", "&&", "CPU_REG_CLASS", "(", "c2", ")", ")", "return", "2", ";", "else", "if", "(", "(", "c1", ">=", "LOAD_FPU_REGS", "&&", "c1", "<=", "FPU_REGS", "&&", "c2", "==", "LOAD_FPU_REGS", ")", "||", "(", "c2", ">=", "LOAD_FPU_REGS", "&&", "c2", "<=", "FPU_REGS", "&&", "c1", "==", "LOAD_FPU_REGS", ")", ")", "return", "2", ";", "else", "return", "22", ";", "}", "</s>" ]

[ "Register", "to", "register", "moves", "are", "cheap", "if", "both", "are", "general", "registers", "." ]

[ "pdp11", "2", "2", "22" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForStrcmp", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src1", ",", "SDValue", "Src2", ",", "MachinePointerInfo", "Op1PtrInfo", ",", "MachinePointerInfo", "Op2PtrInfo", ")", "const", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Src1", ".", "getValueType", "(", ")", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Unused", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "STRCMP", ",", "DL", ",", "VTs", ",", "Chain", ",", "Src1", ",", "Src2", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "CCReg", "=", "Unused", ".", "getValue", "(", "1", ")", ";", "Chain", "=", "Unused", ".", "getValue", "(", "2", ")", ";", "return", "std", "::", "make_pair", "(", "addIPMSequence", "(", "DL", ",", "CCReg", ",", "DAG", ")", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "strcmp", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::i32", "MVT::Other", "SystemZISD::STRCMP", "0", "MVT::i32", "1", "2" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "SITargetLowering", "::", "ConstraintType", "SITargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'s'", ":", "case", "'v'", ":", "case", "'a'", ":", "return", "C_RegisterClass", ";", "}", "}", "if", "(", "isImmConstraint", "(", "Constraint", ")", ")", "{", "return", "C_Other", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "WebAssembly", "::", "isCatch", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "CATCH_I32", ":", "case", "WebAssembly", "::", "CATCH_I32_S", ":", "case", "WebAssembly", "::", "CATCH_I64", ":", "case", "WebAssembly", "::", "CATCH_I64_S", ":", "case", "WebAssembly", "::", "CATCH_ALL", ":", "case", "WebAssembly", "::", "CATCH_ALL_S", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "'true", "'", "if", "the", "clause", "and", "index", "Idx", "is", "a", "catch", "clause", "." ]

[ "WebAssembly", "WebAssembly::isCatch", "WebAssembly::CATCH_I32", "WebAssembly::CATCH_I32_S", "WebAssembly::CATCH_I64", "WebAssembly::CATCH_I64_S", "WebAssembly::CATCH_ALL", "WebAssembly::CATCH_ALL_S" ]

[]

[ "<s>", "const", "DenseSet", "<", "StringRef", ">", "&", "getAttributes", "(", ")", "const", "override", "{", "return", "Attributes", ";", "}", "</s>" ]

[ "Return", "the", "attribute", "set", "for", "this", "global", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "or1k_expand_compare", "(", "rtx", "*", "operands", ")", "{", "rtx", "sr_f", "=", "gen_rtx_REG", "(", "BImode", ",", "SR_F_REGNUM", ")", ";", "rtx", "righthand_op", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "1", ")", ";", "rtx_code", "cmp_code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "bool", "flag_check_ne", "=", "true", ";", "if", "(", "!", "TARGET_SFIMM", "&&", "CONST_INT_P", "(", "righthand_op", ")", ")", "XEXP", "(", "operands", "[", "0", "]", ",", "1", ")", "=", "force_reg", "(", "SImode", ",", "righthand_op", ")", ";", "switch", "(", "cmp_code", ")", "{", "case", "LTGT", ":", "cmp_code", "=", "UNEQ", ";", "flag_check_ne", "=", "false", ";", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "UNORDERED", ";", "flag_check_ne", "=", "false", ";", "break", ";", "default", ":", "break", ";", "}", "PUT_MODE", "(", "operands", "[", "0", "]", ",", "BImode", ")", ";", "PUT_CODE", "(", "operands", "[", "0", "]", ",", "cmp_code", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "sr_f", ",", "operands", "[", "0", "]", ")", ")", ";", "operands", "[", "0", "]", "=", "flag_check_ne", "?", "gen_rtx_NE", "(", "VOIDmode", ",", "sr_f", ",", "const0_rtx", ")", ":", "gen_rtx_EQ", "(", "VOIDmode", ",", "sr_f", ",", "const0_rtx", ")", ";", "operands", "[", "1", "]", "=", "sr_f", ";", "operands", "[", "2", "]", "=", "const0_rtx", ";", "}", "</s>" ]

[ "Used", "to", "expand", "patterns", "``", "movsicc", "''", ",", "``", "movqicc", "''", ",", "``", "movhicc", "''", ",", "``", "cstoresi4", "''", "and", "``", "cbranchsi4", "''", ".", "Expands", "a", "comparison", "where", "OPERANDS", "is", "an", "array", "of", "RTX", "describing", "the", "comparison", ".", "The", "first", "argument", "OPERANDS", "[", "0", "]", "is", "the", "operator", "and", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "are", "the", "operands", ".", "Split", "out", "the", "compare", "into", "SR", "[", "F", "]", "and", "return", "a", "new", "operation", "in", "OPERANDS", "[", "0", "]", ".", "The", "inputs", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "are", "not", "directly", "used", ",", "only", "overridden", "." ]

[ "or1k", "0", "1", "0", "0", "1", "0", "0", "0", "0", "1", "2" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_c_mode_for_suffix", "(", "char", "suffix", ")", "{", "if", "(", "TARGET_FLOAT128", ")", "{", "if", "(", "suffix", "==", "'q'", "||", "suffix", "==", "'Q'", ")", "return", "(", "FLOAT128_IEEE_P", "(", "TFmode", ")", ")", "?", "TFmode", ":", "KFmode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "Target", "hook", "for", "c_mode_for_suffix", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "mmix_output_octa", "(", "FILE", "*", "stream", ",", "HOST_WIDEST_INT", "value", ",", "int", "do_begin_end", ")", "{", "char", "hex_format", "[", "sizeof", "(", "HOST_WIDEST_INT_PRINT_HEX", ")", "]", ";", "if", "(", "do_begin_end", ")", "fprintf", "(", "stream", ",", "\"\\tOCTA \"", ")", ";", "strcpy", "(", "hex_format", ",", "HOST_WIDEST_INT_PRINT_HEX", ")", ";", "hex_format", "[", "0", "]", "=", "'#'", ";", "hex_format", "[", "1", "]", "=", "'0'", ";", "if", "(", "(", "value", "<", "(", "HOST_WIDEST_INT", ")", "0", "&&", "value", ">", "(", "HOST_WIDEST_INT", ")", "-", "10000", ")", "||", "(", "value", ">=", "(", "HOST_WIDEST_INT", ")", "0", "&&", "value", "<=", "(", "HOST_WIDEST_INT", ")", "16384", ")", ")", "fprintf", "(", "stream", ",", "\"%d\"", ",", "(", "int", ")", "value", ")", ";", "else", "if", "(", "value", ">", "(", "HOST_WIDEST_INT", ")", "0", "&&", "value", "<", "(", "(", "HOST_WIDEST_INT", ")", "1", "<<", "31", ")", "*", "2", ")", "fprintf", "(", "stream", ",", "\"#%x\"", ",", "(", "unsigned", "int", ")", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "hex_format", ",", "value", ")", ";", "if", "(", "do_begin_end", ")", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "Print", "a", "64-bit", "value", ",", "optionally", "prefixed", "by", "assembly", "pseudo", "." ]

[ "mmix", "\"\\tOCTA \"", "0", "1", "0", "10000", "0", "16384", "\"%d\"", "0", "1", "31", "2", "\"#%x\"", "\"\\n\"" ]

[]

[ "<s>", "void", "KudeyarInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Kudeyar", "::", "MOV_RM32", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar::MOV_RM32", "0" ]

[]

[ "<s>", "ARMTargetLowering", "::", "ConstraintType", "ARMTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'l'", ":", "return", "C_RegisterClass", ";", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'h'", ":", "return", "C_RegisterClass", ";", "case", "'x'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "return", "C_RegisterClass", ";", "case", "'j'", ":", "return", "C_Other", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'U'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "1", "0", "2", "0" ]

[]

[ "<s>", "void", "TGSIDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "n", ")", "{", "SDLoc", "dl", "(", "n", ")", ";", "switch", "(", "n", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "fi", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "n", ")", "->", "getIndex", "(", ")", ";", "SDValue", "tfi", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "fi", ",", "MVT", "::", "i32", ")", ";", "ReplaceNode", "(", "n", ",", "tfi", ".", "getNode", "(", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "GlobalAddress", ":", "{", "const", "GlobalValue", "*", "gv", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "n", ")", "->", "getGlobal", "(", ")", ";", "SDValue", "tga", "=", "CurDAG", "->", "getTargetGlobalAddress", "(", "gv", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "ReplaceNode", "(", "n", ",", "tga", ".", "getNode", "(", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "n", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "TGSI", "TGSI", "ISD::FrameIndex", "MVT::i32", "ISD::GlobalAddress", "MVT::i32" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "bool", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FI: \"", "<<", "FrameIndex", "<<", "\" Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Corrected Offset \"", "<<", "Offset", "<<", "\" for stack size: \"", "<<", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Offset", ">", "Alpha", "::", "IMM_HIGH", "||", "Offset", "<", "Alpha", "::", "IMM_LOW", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Unconditionally using R28 for evil purposes Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "Alpha", "::", "R28", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "getLower16", "(", "Offset", ")", ")", ";", "MachineInstr", "*", "nMI", "=", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R28", ")", ".", "addImm", "(", "getUpper16", "(", "Offset", ")", ")", ".", "addReg", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ")", ";", "MBB", ".", "insert", "(", "II", ",", "nMI", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "Alpha::R15", "Alpha::R30", "\"FI: \"", "\" Offset: \"", "\"\\n\"", "\"Corrected Offset \"", "\" for stack size: \"", "\"\\n\"", "Alpha::IMM_HIGH", "Alpha::IMM_LOW", "\"Unconditionally using R28 for evil purposes Offset: \"", "\"\\n\"", "1", "Alpha::R28", "Alpha::LDAH", "Alpha::R28", "Alpha::R15", "Alpha::R30" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "tilegx_shift_truncation_mask", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "DImode", "?", "63", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHIFT_TRUNCATION_MASK", ".", "DImode", "shifts", "use", "the", "mode", "matching", "insns", "and", "therefore", "guarantee", "that", "the", "shift", "count", "is", "modulo", "64", ".", "SImode", "shifts", "sometimes", "use", "the", "64", "bit", "version", "so", "do", "not", "hold", "such", "guarantee", "." ]

[ "tilegx", "63", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "AMDGPUAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "AMDGPU", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_si_sopp_br\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_si_rodata\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::NumTargetFixupKinds", "\"fixup_si_sopp_br\"", "0", "16", "\"fixup_si_rodata\"", "0", "32" ]

[]

[ "<s>", "void", "ARMELFStreamer", "::", "Reset", "(", ")", "{", "ExTab", "=", "NULL", ";", "FnStart", "=", "NULL", ";", "Personality", "=", "NULL", ";", "PersonalityIndex", "=", "ARM", "::", "EHABI", "::", "NUM_PERSONALITY_INDEX", ";", "FPReg", "=", "ARM", "::", "SP", ";", "FPOffset", "=", "0", ";", "SPOffset", "=", "0", ";", "PendingOffset", "=", "0", ";", "UsedFP", "=", "false", ";", "CantUnwind", "=", "false", ";", "Opcodes", ".", "clear", "(", ")", ";", "UnwindOpAsm", ".", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "ARM", "ARM", "ARM::EHABI", "ARM::SP", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "adjust_operand", "(", "rtx", "op", ",", "HOST_WIDE_INT", "*", "start", ")", "{", "machine_mode", "mode", ";", "int", "op_size", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ">", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ")", ")", ")", "{", "if", "(", "start", ")", "*", "start", "-=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "-", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ")", ";", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "}", "op_size", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ";", "if", "(", "op_size", "<", "32", ")", "{", "if", "(", "start", ")", "*", "start", "+=", "32", "-", "op_size", ";", "op_size", "=", "32", ";", "}", "mode", "=", "int_mode_for_size", "(", "op_size", ",", "0", ")", ".", "require", "(", ")", ";", "if", "(", "mode", "!=", "GET_MODE", "(", "op", ")", ")", "op", "=", "gen_rtx_SUBREG", "(", "mode", ",", "op", ",", "0", ")", ";", "return", "op", ";", "}", "</s>" ]

[ "When", "insv", "and", "ext", "[", "sz", "]", "v", "ar", "passed", "a", "TI", "SUBREG", ",", "we", "want", "to", "strip", "it", "off", "and", "adjust", "the", "start", "offset", "." ]

[ "spu", "32", "32", "32", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM constant island placement and branch shortening pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM constant island placement and branch shortening pass\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "LEGFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "LEG", "::", "ADJCALLSTACKUP", "||", "I", "->", "getOpcode", "(", ")", "==", "LEG", "::", "ADJCALLSTACKDOWN", ")", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "return", "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", ")", "." ]

[ "LEG", "LEG", "LEG::ADJCALLSTACKUP", "LEG::ADJCALLSTACKDOWN" ]

[]

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

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

[ "LC3b", "LC3b" ]

[]

[ "<s>", "RegisterBankInfo", "::", "InstructionMappings", "AMDGPURegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Size", "=", "getSizeInBits", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "*", "TRI", ")", ";", "InstructionMappings", "AltMappings", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_LOAD", ":", "{", "const", "InstructionMapping", "&", "SSMapping", "=", "getInstructionMapping", "(", "1", ",", "1", ",", "getOperandsMapping", "(", "{", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "Size", ")", ",", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "64", ")", "}", ")", ",", "2", ")", ";", "AltMappings", ".", "push_back", "(", "&", "SSMapping", ")", ";", "const", "InstructionMapping", "&", "VVMapping", "=", "getInstructionMapping", "(", "2", ",", "1", ",", "getOperandsMapping", "(", "{", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ",", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "64", ")", "}", ")", ",", "2", ")", ";", "AltMappings", ".", "push_back", "(", "&", "VVMapping", ")", ";", "const", "InstructionMapping", "&", "VSMapping", "=", "getInstructionMapping", "(", "3", ",", "1", ",", "getOperandsMapping", "(", "{", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ",", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "64", ")", "}", ")", ",", "2", ")", ";", "AltMappings", ".", "push_back", "(", "&", "VSMapping", ")", ";", "return", "AltMappings", ";", "}", "default", ":", "break", ";", "}", "return", "RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "MI", ")", ";", "}", "</s>" ]

[ "Get", "the", "alternative", "mappings", "for", "MI", "." ]

[ "AMDGPU", "AMDGPU", "0", "1", "1", "AMDGPU::getValueMapping", "AMDGPU::SGPRRegBankID", "AMDGPU::getValueMapping", "AMDGPU::SGPRRegBankID", "64", "2", "2", "1", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "64", "2", "3", "1", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "AMDGPU::getValueMapping", "AMDGPU::SGPRRegBankID", "64", "2" ]

[]

[ "<s>", "void", "nds32_expand_prologue_v3push", "(", "void", ")", "{", "int", "fp_adjust", ";", "int", "sp_adjust", ";", "rtx", "Rb", ",", "Re", ";", "rtx", "fp_adjust_insn", ",", "sp_adjust_insn", ";", "nds32_compute_stack_frame", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", ")", "return", ";", "Rb", "=", "gen_rtx_REG", "(", "SImode", ",", "cfun", "->", "machine", "->", "callee_saved_first_gpr_regno", ")", ";", "Re", "=", "gen_rtx_REG", "(", "SImode", ",", "cfun", "->", "machine", "->", "callee_saved_last_gpr_regno", ")", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", ";", "if", "(", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", ")", "{", "nds32_emit_stack_v3push", "(", "Rb", ",", "Re", ",", "GEN_INT", "(", "14", ")", ",", "GEN_INT", "(", "sp_adjust", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "fp_adjust", "=", "cfun", "->", "machine", "->", "fp_size", "+", "cfun", "->", "machine", "->", "gp_size", "+", "cfun", "->", "machine", "->", "lp_size", "+", "cfun", "->", "machine", "->", "callee_saved_gpr_regs_size", "+", "sp_adjust", ";", "fp_adjust_insn", "=", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "fp_adjust", ")", ")", ";", "fp_adjust_insn", "=", "emit_insn", "(", "fp_adjust_insn", ")", ";", "}", "}", "else", "{", "nds32_emit_stack_v3push", "(", "Rb", ",", "Re", ",", "GEN_INT", "(", "14", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "fp_adjust", "=", "cfun", "->", "machine", "->", "fp_size", "+", "cfun", "->", "machine", "->", "gp_size", "+", "cfun", "->", "machine", "->", "lp_size", "+", "cfun", "->", "machine", "->", "callee_saved_gpr_regs_size", ";", "fp_adjust_insn", "=", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "fp_adjust", ")", ")", ";", "fp_adjust_insn", "=", "emit_insn", "(", "fp_adjust_insn", ")", ";", "}", "sp_adjust", "=", "nds32_force_addi_stack_int", "(", "(", "-", "1", ")", "*", "sp_adjust", ")", ";", "if", "(", "sp_adjust", ")", "{", "sp_adjust_insn", "=", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "1", "*", "sp_adjust", ")", ")", ";", "sp_adjust_insn", "=", "emit_insn", "(", "sp_adjust_insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "sp_adjust_insn", ")", "=", "1", ";", "}", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Function", "for", "v3push", "prologue", "." ]

[ "nds32", "14", "14", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::RA" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "&", "FirstLdSt", ",", "MachineInstr", "&", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "}", "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", "*", "DstRC", "->", "getSize", "(", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "inline", "bool", "equal", "(", "tree_map", "*", "a", ",", "tree_map", "*", "b", ")", "{", "return", "a", "->", "base", ".", "from", "==", "b", "->", "base", ".", "from", ";", "}", "</s>" ]

[ "Compare", "H1", "and", "H2", "for", "equivalence", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "{", "auto", "*", "Assembler", "=", "getTargetStreamer", "(", ")", ".", "getStreamer", "(", ")", ".", "getAssemblerPtr", "(", ")", ";", "if", "(", "Assembler", "!=", "nullptr", ")", "{", "RISCVAsmBackend", "&", "MAB", "=", "static_cast", "<", "RISCVAsmBackend", "&", ">", "(", "Assembler", "->", "getBackend", "(", ")", ")", ";", "MAB", ".", "setForceRelocs", "(", ")", ";", "}", "}", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "unsigned", "OperandIdx", "=", "1", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "++", "OperandIdx", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "RISCV", "RISCV", "RISCV", "1", "\"unexpected token\"" ]

[]

[ "<s>", "int", "AArch64AsmParser", "::", "tryParseRegister", "(", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "assert", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", "&&", "\"Token is not an Identifier\"", ")", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "unsigned", "RegNum", "=", "matchRegisterNameAlias", "(", "lowerCase", ",", "false", ")", ";", "if", "(", "RegNum", "==", "0", ")", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"fp\"", ",", "AArch64", "::", "FP", ")", ".", "Case", "(", "\"lr\"", ",", "AArch64", "::", "LR", ")", ".", "Case", "(", "\"x31\"", ",", "AArch64", "::", "XZR", ")", ".", "Case", "(", "\"w31\"", ",", "AArch64", "::", "WZR", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "RegNum", "==", "0", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Token is not an Identifier\"", "0", "\"fp\"", "AArch64::FP", "\"lr\"", "AArch64::LR", "\"x31\"", "AArch64::XZR", "\"w31\"", "AArch64::WZR", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "frv_registers_update", "(", "rtx", "x", ")", "{", "regstate_t", "flags", ";", "flags", "=", "REGSTATE_MODIFIED", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "COND_EXEC", ")", "{", "flags", "|=", "frv_cond_flags", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "}", "note_pattern_stores", "(", "x", ",", "frv_registers_update_1", ",", "&", "flags", ")", ";", "}", "</s>" ]

[ "Update", "the", "register", "state", "information", "for", "an", "instruction", "whose", "body", "is", "X", "." ]

[ "frv", "0", "1" ]

[]

[ "<s>", "bool", "sh_cfun_trap_exit_p", "(", "void", ")", "{", "return", "(", "lookup_attribute", "(", "\"trap_exit\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", "==", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "function", "has", "a", "``", "trap_exit", "''", "attribute", "set", "." ]

[ "sh", "\"trap_exit\"" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* PPC CTR Loops *********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "I", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineLoop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "{", "Changed", "|=", "convertToCTRLoop", "(", "L", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"********* PPC CTR Loops *********\\n\"" ]

[]

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

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

[ "SNES", "SNES" ]

[]

[ "<s>", "static", "rtx", "arm_gen_load_multiple_1", "(", "int", "count", ",", "int", "*", "regs", ",", "rtx", "*", "mems", ",", "rtx", "basereg", ",", "HOST_WIDE_INT", "wback_offset", ")", "{", "int", "i", "=", "0", ",", "j", ";", "rtx", "result", ";", "if", "(", "!", "multiple_operation_profitable_p", "(", "false", ",", "count", ",", "0", ")", ")", "{", "rtx", "seq", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "regs", "[", "i", "]", ")", ",", "mems", "[", "i", "]", ")", ";", "if", "(", "wback_offset", "!=", "0", ")", "emit_move_insn", "(", "basereg", ",", "plus_constant", "(", "Pmode", ",", "basereg", ",", "wback_offset", ")", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "seq", ";", "}", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "(", "wback_offset", "!=", "0", "?", "1", ":", "0", ")", ")", ")", ";", "if", "(", "wback_offset", "!=", "0", ")", "{", "XVECEXP", "(", "result", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "basereg", ",", "plus_constant", "(", "Pmode", ",", "basereg", ",", "wback_offset", ")", ")", ";", "i", "=", "1", ";", "count", "++", ";", "}", "for", "(", "j", "=", "0", ";", "i", "<", "count", ";", "i", "++", ",", "j", "++", ")", "XVECEXP", "(", "result", ",", "0", ",", "i", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "regs", "[", "j", "]", ")", ",", "mems", "[", "j", "]", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Generate", "a", "load-multiple", "instruction", ".", "COUNT", "is", "the", "number", "of", "loads", "in", "the", "instruction", ";", "REGS", "and", "MEMS", "are", "arrays", "containing", "the", "operands", ".", "BASEREG", "is", "the", "base", "register", "to", "be", "used", "in", "addressing", "the", "memory", "operands", ".", "WBACK_OFFSET", "is", "nonzero", "if", "the", "instruction", "should", "update", "the", "base", "register", "." ]

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

[]

[ "<s>", "void", "VEFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "VEMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "VEMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "VEInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "const", "VERegisterInfo", "&", "RegInfo", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "bool", "NeedsStackRealignment", "=", "RegInfo", ".", "needsStackRealignment", "(", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "NeedsStackRealignment", "&&", "MFI", ".", "getMaxAlign", "(", ")", ">", "getStackAlign", "(", ")", ")", "report_fatal_error", "(", "\"Function \\\"\"", "+", "Twine", "(", "MF", ".", "getName", "(", ")", ")", "+", "\"\\\" required \"", "\"stack re-alignment, but LLVM couldn't handle it \"", "\"(probably because it has a dynamic alloca).\"", ")", ";", "uint64_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "NumBytes", "=", "STI", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "}", "NumBytes", "=", "alignTo", "(", "NumBytes", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "MFI", ".", "setStackSize", "(", "NumBytes", ")", ";", "emitPrologueInsns", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "true", ")", ";", "if", "(", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "VE", "::", "ORri", ")", ",", "VE", "::", "SX9", ")", ".", "addReg", "(", "VE", "::", "SX11", ")", ".", "addImm", "(", "0", ")", ";", "MaybeAlign", "RuntimeAlign", "=", "NeedsStackRealignment", "?", "MaybeAlign", "(", "MFI", ".", "getMaxAlign", "(", ")", ")", ":", "None", ";", "assert", "(", "(", "RuntimeAlign", "==", "None", "||", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "&&", "\"SP has to be saved in order to align variable sized stack object!\"", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "-", "(", "int64_t", ")", "NumBytes", ",", "RuntimeAlign", ")", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "VE", "::", "ORri", ")", ",", "VE", "::", "SX17", ")", ".", "addReg", "(", "VE", "::", "SX11", ")", ".", "addImm", "(", "0", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "emitSPExtend", "(", "MF", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "VE", "\"Shrink-wrapping not yet supported\"", "VE", "VE", "\"Function \\\"\"", "\"\\\" required \"", "\"stack re-alignment, but LLVM couldn't handle it \"", "\"(probably because it has a dynamic alloca).\"", "VE::ORri", "VE::SX9", "VE::SX11", "0", "\"SP has to be saved in order to align variable sized stack object!\"", "VE::ORri", "VE::SX17", "VE::SX11", "0", "0" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "initQueues", "(", "ArrayRef", "<", "SUnit", "*", ">", "TopRoots", ",", "ArrayRef", "<", "SUnit", "*", ">", "BotRoots", ")", "{", "for", "(", "SmallVectorImpl", "<", "SUnit", "*", ">", "::", "const_iterator", "I", "=", "TopRoots", ".", "begin", "(", ")", ",", "E", "=", "TopRoots", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "SchedImpl", "->", "releaseTopNode", "(", "*", "I", ")", ";", "}", "for", "(", "SmallVectorImpl", "<", "SUnit", "*", ">", "::", "const_reverse_iterator", "I", "=", "BotRoots", ".", "rbegin", "(", ")", ",", "E", "=", "BotRoots", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "SchedImpl", "->", "releaseBottomNode", "(", "*", "I", ")", ";", "}", "releaseSuccessors", "(", "&", "EntrySU", ")", ";", "releasePredecessors", "(", "&", "ExitSU", ")", ";", "SchedImpl", "->", "registerRoots", "(", ")", ";", "CurrentTop", "=", "nextIfDebug", "(", "RegionBegin", ",", "RegionEnd", ")", ";", "CurrentBottom", "=", "RegionEnd", ";", "TopBundleMIs", ".", "clear", "(", ")", ";", "BottomBundleMIs", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Release", "ExitSU", "predecessors", "and", "setup", "scheduler", "queues", "." ]

[ "Patmos" ]

[]

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

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

[ "MSP430" ]

[]

[ "<s>", "bool", "cris_return_address_on_stack", "(", "void", ")", "{", "return", "regs_ever_live", "[", "CRIS_SRP_REGNUM", "]", "||", "cfun", "->", "machine", "->", "needs_return_address_on_stack", ";", "}", "</s>" ]

[ "Accessor", "used", "in", "cris.md", ":", "return", "because", "cfun-", ">", "machine", "is", "n't", "available", "there", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "SNESInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected opcode!\"", ")", ";", "case", "SNES", "::", "JMPk", ":", "case", "SNES", "::", "CALLk", ":", "assert", "(", "BrOffset", ">=", "0", "&&", "\"offset must be absolute address\"", ")", ";", "return", "isUIntN", "(", "16", ",", "BrOffset", ")", ";", "case", "SNES", "::", "RCALLk", ":", "case", "SNES", "::", "RJMPk", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "SNES", "::", "BRBSsk", ":", "case", "SNES", "::", "BRBCsk", ":", "case", "SNES", "::", "BREQk", ":", "case", "SNES", "::", "BRNEk", ":", "case", "SNES", "::", "BRSHk", ":", "case", "SNES", "::", "BRLOk", ":", "case", "SNES", "::", "BRMIk", ":", "case", "SNES", "::", "BRPLk", ":", "case", "SNES", "::", "BRGEk", ":", "case", "SNES", "::", "BRLTk", ":", "return", "isIntN", "(", "7", ",", "BrOffset", ")", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "SNES", "SNES", "\"unexpected opcode!\"", "SNES::JMPk", "SNES::CALLk", "0", "\"offset must be absolute address\"", "16", "SNES::RCALLk", "SNES::RJMPk", "13", "SNES::BRBSsk", "SNES::BRBCsk", "SNES::BREQk", "SNES::BRNEk", "SNES::BRSHk", "SNES::BRLOk", "SNES::BRMIk", "SNES::BRPLk", "SNES::BRGEk", "SNES::BRLTk", "7" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getPartialRegUpdateClearance", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "SwiftPartialUpdateClearance", "||", "!", "(", "Subtarget", ".", "isSwift", "(", ")", "||", "Subtarget", ".", "isCortexA15", "(", ")", ")", ")", "return", "0", ";", "assert", "(", "TRI", "&&", "\"Need TRI instance\"", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "readsReg", "(", ")", ")", "return", "0", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "int", "UseOp", "=", "-", "1", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "FCONSTS", ":", "case", "ARM", "::", "VMOVSR", ":", "case", "ARM", "::", "VMOVv8i8", ":", "case", "ARM", "::", "VMOVv4i16", ":", "case", "ARM", "::", "VMOVv2i32", ":", "case", "ARM", "::", "VMOVv2f32", ":", "case", "ARM", "::", "VMOVv1i64", ":", "UseOp", "=", "MI", "->", "findRegisterUseOperandIdx", "(", "Reg", ",", "false", ",", "TRI", ")", ";", "break", ";", "case", "ARM", "::", "VLD1LNd32", ":", "UseOp", "=", "3", ";", "break", ";", "default", ":", "return", "0", ";", "}", "if", "(", "UseOp", "!=", "-", "1", "&&", "MI", "->", "getOperand", "(", "UseOp", ")", ".", "readsReg", "(", ")", ")", "return", "0", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", "{", "if", "(", "!", "MO", ".", "getSubReg", "(", ")", "||", "MI", "->", "readsVirtualRegister", "(", "Reg", ")", ")", "return", "0", ";", "}", "else", "if", "(", "ARM", "::", "SPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "DReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "Reg", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DReg", "||", "!", "MI", "->", "definesRegister", "(", "DReg", ",", "TRI", ")", ")", "return", "0", ";", "}", "return", "SwiftPartialUpdateClearance", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "a", "partial", "register", "update", "." ]

[ "ARM", "ARM", "0", "\"Need TRI instance\"", "0", "1", "ARM::VLDRS", "ARM::FCONSTS", "ARM::VMOVSR", "ARM::VMOVv8i8", "ARM::VMOVv4i16", "ARM::VMOVv2i32", "ARM::VMOVv2f32", "ARM::VMOVv1i64", "ARM::VLD1LNd32", "3", "0", "1", "0", "0", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0" ]

[]

[ "<s>", "static", "inline", "bool", "ia64_reg_ok_for_base_p", "(", "const_rtx", "reg", ",", "bool", "strict", ")", "{", "if", "(", "strict", "&&", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "reg", ")", ")", ")", "return", "true", ";", "else", "if", "(", "!", "strict", "&&", "(", "GENERAL_REGNO_P", "(", "REGNO", "(", "reg", ")", ")", "||", "!", "HARD_REGISTER_P", "(", "reg", ")", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "REG", "(", "assumed", "to", "be", "a", "`", "reg", "'", "RTX", ")", "is", "valid", "for", "use", "as", "a", "base", "register", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "Parser", ".", "Warning", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "Cpu0PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createCpu0EmitGPRestorePass", "(", "getCpu0TargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "visium_init_libfuncs", "(", "void", ")", "{", "if", "(", "!", "TARGET_BMI", ")", "long_int_memcpy_libfunc", "=", "init_one_libfunc", "(", "\"__long_int_memcpy\"", ")", ";", "wrd_memcpy_libfunc", "=", "init_one_libfunc", "(", "\"__wrd_memcpy\"", ")", ";", "byt_memcpy_libfunc", "=", "init_one_libfunc", "(", "\"__byt_memcpy\"", ")", ";", "long_int_memset_libfunc", "=", "init_one_libfunc", "(", "\"__long_int_memset\"", ")", ";", "wrd_memset_libfunc", "=", "init_one_libfunc", "(", "\"__wrd_memset\"", ")", ";", "byt_memset_libfunc", "=", "init_one_libfunc", "(", "\"__byt_memset\"", ")", ";", "set_trampoline_parity_libfunc", "=", "init_one_libfunc", "(", "\"__set_trampoline_parity\"", ")", ";", "}", "</s>" ]

[ "Register", "the", "Visium-specific", "libfuncs", "with", "the", "middle-end", "." ]

[ "visium", "\"__long_int_memcpy\"", "\"__wrd_memcpy\"", "\"__byt_memcpy\"", "\"__long_int_memset\"", "\"__wrd_memset\"", "\"__byt_memset\"", "\"__set_trampoline_parity\"" ]

[]

[ "<s>", "int", "loongarch_idiv_insns", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "int", "count", ";", "count", "=", "1", ";", "if", "(", "loongarch_check_zero_div_p", "(", ")", ")", "count", "+=", "2", ";", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "for", "an", "integer", "division", "." ]

[ "loongarch", "1", "2" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MINA32AsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "Operands", ".", "push_back", "(", "MINA32Operand", "::", "CreateToken", "(", "Head", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Head", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list (first)\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Head", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "0", "MINA32Operand::CreateToken", "\"unexpected token in argument list (first)\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "static", "rtx", "aarch64_struct_value_rtx", "(", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "AARCH64_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_STRUCT_VALUE_RTX", "." ]

[ "aarch64" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "J2AsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "auto", "MOTW", "=", "llvm", "::", "make_unique", "<", "J2ELFObjectWriter", ">", "(", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ",", "ELF", "::", "EM_J2", ")", ";", "return", "createELFObjectWriter", "(", "std", "::", "move", "(", "MOTW", ")", ",", "OS", ",", "true", ")", ";", "}", "</s>" ]

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

[ "J2", "J2", "J2", "J2" ]

[]

[ "<s>", "void", "MipsSETargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "Ops", ".", "push_back", "(", "Callee", ")", ";", "MipsTargetLowering", "::", "getOpndList", "(", "Ops", ",", "RegsToPass", ",", "IsPICCall", ",", "GlobalOrExternal", ",", "InternalLinkage", ",", "CLI", ",", "Callee", ",", "Chain", ")", ";", "}", "</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" ]

[]

[ "<s>", "static", "bool", "rs6000_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "fntype", ";", "if", "(", "decl", ")", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "else", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "if", "(", "TARGET_ALTIVEC_ABI", "&&", "TARGET_ALTIVEC_VRSAVE", "&&", "!", "(", "decl", "&&", "decl", "==", "current_function_decl", ")", ")", "{", "function_args_iterator", "args_iter", ";", "tree", "type", ";", "int", "nvreg", "=", "0", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "++", ";", "FOREACH_FUNCTION_ARGS", "(", "TREE_TYPE", "(", "current_function_decl", ")", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "--", ";", "if", "(", "nvreg", ">", "0", ")", "return", "false", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "||", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "decl", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "!", "TARGET_SECURE_PLT", "||", "!", "flag_pic", "||", "(", "decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", ")", ")", ")", "{", "tree", "attr_list", "=", "TYPE_ATTRIBUTES", "(", "fntype", ")", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "attr_list", ")", "||", "lookup_attribute", "(", "\"shortcall\"", ",", "attr_list", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Say", "whether", "a", "function", "is", "a", "candidate", "for", "sibcall", "handling", "or", "not", ".", "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ".", "Also", ",", "we", "ca", "n't", "do", "it", "if", "there", "are", "any", "vector", "parameters", ";", "there", "'s", "nowhere", "to", "put", "the", "VRsave", "code", "so", "it", "works", ";", "note", "that", "functions", "with", "vector", "parameters", "are", "required", "to", "have", "a", "prototype", ",", "so", "the", "argument", "type", "info", "must", "be", "available", "here", ".", "(", "The", "tail", "recursion", "case", "can", "work", "with", "vector", "parameters", ",", "but", "there", "'s", "no", "way", "to", "distinguish", "here", ".", ")" ]

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "GlobalBaseReg", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "X86", "X86", "X86ISD::GlobalBaseReg" ]

[]

[ "<s>", "static", "inline", "bool", "current_function_saves_lr", "(", "void", ")", "{", "return", "current_frame_info", ".", "save_lr", "!=", "0", ";", "}", "</s>" ]

[ "Accessor", "for", "current_frame_info.save_lr", "." ]

[ "visium", "0" ]

[]

[ "<s>", "void", "BlockWaitcntBrackets", "::", "print", "(", "raw_ostream", "&", "OS", ")", "{", "OS", "<<", "'\\n'", ";", "for", "(", "enum", "InstCounterType", "T", "=", "VM_CNT", ";", "T", "<", "NUM_INST_CNTS", ";", "T", "=", "(", "enum", "InstCounterType", ")", "(", "T", "+", "1", ")", ")", "{", "int", "LB", "=", "getScoreLB", "(", "T", ")", ";", "int", "UB", "=", "getScoreUB", "(", "T", ")", ";", "switch", "(", "T", ")", "{", "case", "VM_CNT", ":", "OS", "<<", "\" VM_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "LGKM_CNT", ":", "OS", "<<", "\" LGKM_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "EXP_CNT", ":", "OS", "<<", "\" EXP_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "default", ":", "OS", "<<", "\" UNKNOWN(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "}", "if", "(", "LB", "<", "UB", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "getMaxVGPR", "(", ")", ";", "J", "++", ")", "{", "int", "RegScore", "=", "getRegScore", "(", "J", ",", "T", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "int", "RelScore", "=", "RegScore", "-", "LB", "-", "1", ";", "if", "(", "J", "<", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ")", "{", "OS", "<<", "RelScore", "<<", "\":v\"", "<<", "J", "<<", "\" \"", ";", "}", "else", "{", "OS", "<<", "RelScore", "<<", "\":ds \"", ";", "}", "}", "if", "(", "T", "==", "LGKM_CNT", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "getMaxSGPR", "(", ")", ";", "J", "++", ")", "{", "int", "RegScore", "=", "getRegScore", "(", "J", "+", "NUM_ALL_VGPRS", ",", "LGKM_CNT", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "int", "RelScore", "=", "RegScore", "-", "LB", "-", "1", ";", "OS", "<<", "RelScore", "<<", "\":s\"", "<<", "J", "<<", "\" \"", ";", "}", "}", "}", "OS", "<<", "'\\n'", ";", "}", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AMDGPU", "1", "\" VM_CNT(\"", "\"): \"", "\" LGKM_CNT(\"", "\"): \"", "\" EXP_CNT(\"", "\"): \"", "\" UNKNOWN(\"", "\"): \"", "0", "1", "\":v\"", "\" \"", "\":ds \"", "0", "1", "\":s\"", "\" \"" ]

[]

[ "<s>", "void", "init_convex", "(", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "A_REGNO_P", "(", "regno", ")", ")", "{", "regno_ok_for_index_p", "[", "regno", "]", "=", "1", ";", "regno_reg_class", "[", "regno", "]", "=", "INDEX_REGS", ";", "}", "else", "{", "regno_ok_for_index_p", "[", "regno", "]", "=", "0", ";", "regno_reg_class", "[", "regno", "]", "=", "S_REGS", ";", "}", "regno_ok_for_index_p", "[", "STACK_POINTER_REGNUM", "]", "=", "0", ";", "regno_reg_class", "[", "STACK_POINTER_REGNUM", "]", "=", "SP_REGS", ";", "regno_ok_for_index_p", "[", "VIRTUAL_INCOMING_ARGS_REGNUM", "]", "=", "1", ";", "regno_ok_for_index_p", "[", "VIRTUAL_STACK_VARS_REGNUM", "]", "=", "1", ";", "regno_ok_for_index_p", "[", "VIRTUAL_STACK_DYNAMIC_REGNUM", "]", "=", "0", ";", "regno_ok_for_index_p", "[", "VIRTUAL_OUTGOING_ARGS_REGNUM", "]", "=", "0", ";", "regno_ok_for_index_p", "[", "-", "1", "]", "=", "0", ";", "reg_class_from_letter", "[", "'a'", "]", "=", "A_REGS", ";", "reg_class_from_letter", "[", "'A'", "]", "=", "INDEX_REGS", ";", "reg_class_from_letter", "[", "'d'", "]", "=", "S_REGS", ";", "psw_disable_float", "(", ")", ";", "}", "</s>" ]

[ "Here", "from", "OVERRIDE_OPTIONS", "at", "startup", ".", "Initialize", "constant", "tables", "." ]

[ "convex", "0", "1", "0", "0", "1", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "Mips16DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "return", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "PPC", "::", "INLINEASM", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "else", "if", "(", "Opcode", "==", "TargetOpcode", "::", "STACKMAP", ")", "{", "StackMapOpers", "Opers", "(", "&", "MI", ")", ";", "return", "Opers", ".", "getNumPatchBytes", "(", ")", ";", "}", "else", "if", "(", "Opcode", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "PatchPointOpers", "Opers", "(", "&", "MI", ")", ";", "return", "Opers", ".", "getNumPatchBytes", "(", ")", ";", "}", "else", "{", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "Opcode", ")", ";", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "PowerPC", "PPC", "PPC::INLINEASM", "0" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "return", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "==", "RealCalleeBits", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "AMDGPU" ]

[]

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

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

[ "WebAssembly" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "splitValueIntoRegisterParts", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Val", ",", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "bool", "IsABIRegCopy", "=", "CC", ".", "hasValue", "(", ")", ";", "EVT", "ValueVT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "IsABIRegCopy", "&&", "(", "ValueVT", "==", "MVT", "::", "f16", "||", "ValueVT", "==", "MVT", "::", "bf16", ")", "&&", "PartVT", "==", "MVT", "::", "f32", ")", "{", "unsigned", "ValueBits", "=", "ValueVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "PartBits", "=", "PartVT", ".", "getSizeInBits", "(", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "getIntegerVT", "(", "ValueBits", ")", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "getIntegerVT", "(", "PartBits", ")", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "PartVT", ",", "Val", ")", ";", "Parts", "[", "0", "]", "=", "Val", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Target-specific", "splitting", "of", "values", "into", "parts", "that", "fit", "a", "register", "storing", "a", "legal", "type", "." ]

[ "ARM", "ARM", "MVT::f16", "MVT::bf16", "MVT::f32", "ISD::BITCAST", "MVT::getIntegerVT", "ISD::ANY_EXTEND", "MVT::getIntegerVT", "ISD::BITCAST", "0" ]

[]

[ "<s>", "static", "rtx", "mn10300_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "result", "=", "NULL_RTX", ";", "int", "size", ";", "int", "nregs", "=", "2", ";", "size", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "3", ")", "&", "~", "3", ";", "if", "(", "cum", "->", "nbytes", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "result", ";", "if", "(", "arg", ".", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "result", ";", "switch", "(", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", "{", "case", "0", ":", "result", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "FIRST_ARGUMENT_REGNUM", ")", ";", "break", ";", "case", "1", ":", "result", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "FIRST_ARGUMENT_REGNUM", "+", "1", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "to", "represent", "where", "a", "value", "with", "mode", "MODE", "will", "be", "returned", "from", "a", "function", ".", "If", "the", "result", "is", "NULL_RTX", ",", "the", "argument", "is", "pushed", "." ]

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

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "CallGraphResourceInfo", ".", "clear", "(", ")", ";", "if", "(", "AMDGPU", "::", "isGFX10", "(", "*", "getGlobalSTI", "(", ")", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitCodeEnd", "(", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isGFX10" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "uint64_t", "Code", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "i", "++", ")", "{", "EmitByte", "(", "Code", ",", "OS", ")", ";", "Code", ">>=", "8", ";", "}", "}", "</s>" ]

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

[ "Z80", "0", "8" ]

[]

[ "<s>", "bool", "rx_match_ccmode", "(", "rtx", "insn", ",", "machine_mode", "cc_mode", ")", "{", "rtx", "op1", ",", "flags", ";", "machine_mode", "flags_mode", ";", "gcc_checking_assert", "(", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", "==", "2", ")", ";", "op1", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "op1", ")", ")", "==", "COMPARE", ")", ";", "flags", "=", "SET_DEST", "(", "op1", ")", ";", "flags_mode", "=", "GET_MODE", "(", "flags", ")", ";", "if", "(", "GET_MODE", "(", "SET_SRC", "(", "op1", ")", ")", "!=", "flags_mode", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "flags_mode", ")", "!=", "MODE_CC", ")", "return", "false", ";", "if", "(", "flags_from_mode", "(", "flags_mode", ")", "&", "~", "flags_from_mode", "(", "cc_mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "helper", "function", "for", "matching", "parallels", "that", "set", "the", "flags", "." ]

[ "rx", "0", "2", "0", "0" ]

[]

[ "<s>", "static", "tree", "nvptx_lockless_update", "(", "location_t", "loc", ",", "gimple_stmt_iterator", "*", "gsi", ",", "tree", "ptr", ",", "tree", "var", ",", "tree_code", "op", ")", "{", "unsigned", "fn", "=", "NVPTX_BUILTIN_CMP_SWAP", ";", "tree_code", "code", "=", "NOP_EXPR", ";", "tree", "arg_type", "=", "unsigned_type_node", ";", "tree", "var_type", "=", "TREE_TYPE", "(", "var", ")", ";", "if", "(", "TREE_CODE", "(", "var_type", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "var_type", ")", "==", "REAL_TYPE", ")", "code", "=", "VIEW_CONVERT_EXPR", ";", "if", "(", "TYPE_SIZE", "(", "var_type", ")", "==", "TYPE_SIZE", "(", "long_long_unsigned_type_node", ")", ")", "{", "arg_type", "=", "long_long_unsigned_type_node", ";", "fn", "=", "NVPTX_BUILTIN_CMP_SWAPLL", ";", "}", "tree", "swap_fn", "=", "nvptx_builtin_decl", "(", "fn", ",", "true", ")", ";", "gimple_seq", "init_seq", "=", "NULL", ";", "tree", "init_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "tree", "init_expr", "=", "omp_reduction_init_op", "(", "loc", ",", "op", ",", "var_type", ")", ";", "init_expr", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "init_expr", ")", ";", "gimplify_assign", "(", "init_var", ",", "init_expr", ",", "&", "init_seq", ")", ";", "gimple", "*", "init_end", "=", "gimple_seq_last", "(", "init_seq", ")", ";", "gsi_insert_seq_before", "(", "gsi", ",", "init_seq", ",", "GSI_SAME_STMT", ")", ";", "basic_block", "pre_bb", "=", "gsi_bb", "(", "*", "gsi", ")", ";", "edge", "pre_edge", "=", "split_block", "(", "pre_bb", ",", "init_end", ")", ";", "basic_block", "loop_bb", "=", "pre_edge", "->", "dest", ";", "pre_bb", "=", "pre_edge", "->", "src", ";", "*", "gsi", "=", "gsi_for_stmt", "(", "gsi_stmt", "(", "*", "gsi", ")", ")", ";", "tree", "expect_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "tree", "actual_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "tree", "write_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "gimple_seq", "red_seq", "=", "NULL", ";", "tree", "write_expr", "=", "fold_build1", "(", "code", ",", "var_type", ",", "expect_var", ")", ";", "write_expr", "=", "fold_build2", "(", "op", ",", "var_type", ",", "write_expr", ",", "var", ")", ";", "write_expr", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "write_expr", ")", ";", "gimplify_assign", "(", "write_var", ",", "write_expr", ",", "&", "red_seq", ")", ";", "gsi_insert_seq_before", "(", "gsi", ",", "red_seq", ",", "GSI_SAME_STMT", ")", ";", "gimple_seq", "latch_seq", "=", "NULL", ";", "tree", "swap_expr", "=", "build_call_expr_loc", "(", "loc", ",", "swap_fn", ",", "3", ",", "ptr", ",", "expect_var", ",", "write_var", ")", ";", "gimplify_assign", "(", "actual_var", ",", "swap_expr", ",", "&", "latch_seq", ")", ";", "gcond", "*", "cond", "=", "gimple_build_cond", "(", "EQ_EXPR", ",", "actual_var", ",", "expect_var", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "gimple_seq_add_stmt", "(", "&", "latch_seq", ",", "cond", ")", ";", "gimple", "*", "latch_end", "=", "gimple_seq_last", "(", "latch_seq", ")", ";", "gsi_insert_seq_before", "(", "gsi", ",", "latch_seq", ",", "GSI_SAME_STMT", ")", ";", "edge", "post_edge", "=", "split_block", "(", "loop_bb", ",", "latch_end", ")", ";", "basic_block", "post_bb", "=", "post_edge", "->", "dest", ";", "loop_bb", "=", "post_edge", "->", "src", ";", "*", "gsi", "=", "gsi_for_stmt", "(", "gsi_stmt", "(", "*", "gsi", ")", ")", ";", "post_edge", "->", "flags", "^=", "EDGE_TRUE_VALUE", "|", "EDGE_FALLTHRU", ";", "edge", "loop_edge", "=", "make_edge", "(", "loop_bb", ",", "loop_bb", ",", "EDGE_FALSE_VALUE", ")", ";", "set_immediate_dominator", "(", "CDI_DOMINATORS", ",", "loop_bb", ",", "pre_bb", ")", ";", "set_immediate_dominator", "(", "CDI_DOMINATORS", ",", "post_bb", ",", "loop_bb", ")", ";", "gphi", "*", "phi", "=", "create_phi_node", "(", "expect_var", ",", "loop_bb", ")", ";", "add_phi_arg", "(", "phi", ",", "init_var", ",", "pre_edge", ",", "loc", ")", ";", "add_phi_arg", "(", "phi", ",", "actual_var", ",", "loop_edge", ",", "loc", ")", ";", "loop", "*", "loop", "=", "alloc_loop", "(", ")", ";", "loop", "->", "header", "=", "loop_bb", ";", "loop", "->", "latch", "=", "loop_bb", ";", "add_loop", "(", "loop", ",", "loop_bb", "->", "loop_father", ")", ";", "return", "fold_build1", "(", "code", ",", "var_type", ",", "write_var", ")", ";", "}", "</s>" ]

[ "Insert", "code", "to", "locklessly", "update", "*", "PTR", "with", "*", "PTR", "OP", "VAR", "just", "before", "GSI", ".", "We", "use", "a", "lockless", "scheme", "for", "nearly", "all", "case", ",", "which", "looks", "like", ":", "actual", "=", "initval", "(", "OP", ")", ";", "do", "{", "guess", "=", "actual", ";", "write", "=", "guess", "OP", "myval", ";", "actual", "=", "cmp", "&", "swap", "(", "ptr", ",", "guess", ",", "write", ")", "}", "while", "(", "actual", "bit-different-to", "guess", ")", ";", "return", "write", ";", "This", "relies", "on", "a", "cmp", "&", "swap", "instruction", ",", "which", "is", "available", "for", "32-", "and", "64-bit", "types", ".", "Larger", "types", "must", "use", "a", "locking", "scheme", "." ]

[ "nvptx", "3" ]

[]

[ "<s>", "void", "M68kInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", "==", "4", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "TRI", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "M68k", "::", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIndex", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "4", "\"Stack slot too small for store\"", "M68k::addFrameReference" ]

[]

[ "<s>", "void", "CSKYAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "void", "TMS320C64XInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "srcReg", ",", "bool", "isKill", ",", "int", "frameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "rc", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "srcReg", ")", ")", "{", "assert", "(", "RC", ")", ";", "if", "(", "RC", "==", "TMS320C64X", "::", "PredRegsRegisterClass", ")", "rc", "=", "TMS320C64X", "::", "ARegsRegisterClass", ";", "else", "rc", "=", "RC", ";", "}", "else", "rc", "=", "findRegisterSide", "(", "srcReg", ",", "MBB", ".", "getParent", "(", ")", ")", ";", "bool", "xdata", "=", "(", "rc", "==", "TMS320C64X", "::", "BRegsRegisterClass", ")", ";", "addFormOp", "(", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TMS320C64X", "::", "word_store_1", ")", ")", ".", "addReg", "(", "TMS320C64X", "::", "A15", ")", ".", "addFrameIndex", "(", "frameIndex", ")", ".", "addReg", "(", "srcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ")", ",", "TMS320C64XII", "::", "unit_d", ",", "xdata", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64X::PredRegsRegisterClass", "TMS320C64X::ARegsRegisterClass", "TMS320C64X::BRegsRegisterClass", "TMS320C64X::word_store_1", "TMS320C64X::A15", "TMS320C64XII::unit_d" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isExtFreeImpl", "(", "const", "Instruction", "*", "Ext", ")", "const", "{", "if", "(", "isa", "<", "FPExtInst", ">", "(", "Ext", ")", ")", "return", "false", ";", "if", "(", "Ext", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "for", "(", "const", "Use", "&", "U", ":", "Ext", "->", "uses", "(", ")", ")", "{", "const", "Instruction", "*", "Instr", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "switch", "(", "Instr", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Shl", ":", "if", "(", "!", "isa", "<", "ConstantInt", ">", "(", "Instr", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "break", ";", "case", "Instruction", "::", "GetElementPtr", ":", "{", "gep_type_iterator", "GTI", "=", "gep_type_begin", "(", "Instr", ")", ";", "std", "::", "advance", "(", "GTI", ",", "U", ".", "getOperandNo", "(", ")", ")", ";", "Type", "*", "IdxTy", "=", "*", "GTI", ";", "uint64_t", "ShiftAmt", "=", "countTrailingZeros", "(", "getDataLayout", "(", ")", "->", "getTypeStoreSizeInBits", "(", "IdxTy", ")", ")", "-", "3", ";", "if", "(", "ShiftAmt", "==", "0", "||", "ShiftAmt", ">", "4", ")", "return", "false", ";", "break", ";", "}", "case", "Instruction", "::", "Trunc", ":", "if", "(", "Instr", "->", "getType", "(", ")", "==", "Ext", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", "continue", ";", "default", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "extension", "represented", "by", "I", "is", "free", "." ]

[ "AArch64", "AArch64", "1", "3", "0", "4", "0" ]

[]

[ "<s>", "static", "void", "rs6000_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "TARGET_DEBUG_STACK", ")", "debug_stack_info", "(", "info", ")", ";", "if", "(", "info", "->", "first_fp_reg_save", "<", "64", "&&", "!", "FP_SAVE_INLINE", "(", "info", "->", "first_fp_reg_save", ")", ")", "fprintf", "(", "file", ",", "\"\\t.extern %s%d%s\\n\\t.extern %s%d%s\\n\"", ",", "SAVE_FP_PREFIX", ",", "info", "->", "first_fp_reg_save", "-", "32", ",", "SAVE_FP_SUFFIX", ",", "RESTORE_FP_PREFIX", ",", "info", "->", "first_fp_reg_save", "-", "32", ",", "RESTORE_FP_SUFFIX", ")", ";", "if", "(", "!", "TARGET_POWER", "&&", "!", "TARGET_POWERPC", "&&", "!", "common_mode_defined", ")", "{", "fputs", "(", "\"\\t.extern __mulh\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.extern __mull\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.extern __divss\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.extern __divus\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.extern __quoss\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.extern __quous\\n\"", ",", "file", ")", ";", "common_mode_defined", "=", "1", ";", "}", "if", "(", "!", "HAVE_prologue", ")", "{", "start_sequence", "(", ")", ";", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "rs6000_emit_prologue", "(", ")", ";", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "{", "rtx", "insn", ";", "unsigned", "addr", "=", "0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "0", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "INSN_ADDRESSES_NEW", "(", "insn", ",", "addr", ")", ";", "addr", "+=", "4", ";", "}", "}", "if", "(", "TARGET_DEBUG_STACK", ")", "debug_rtx_list", "(", "get_insns", "(", ")", ",", "100", ")", ";", "final", "(", "get_insns", "(", ")", ",", "file", ",", "FALSE", ")", ";", "end_sequence", "(", ")", ";", "}", "rs6000_pic_labelno", "++", ";", "}", "</s>" ]

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

[ "rs6000", "64", "\"\\t.extern %s%d%s\\n\\t.extern %s%d%s\\n\"", "32", "32", "\"\\t.extern __mulh\\n\"", "\"\\t.extern __mull\\n\"", "\"\\t.extern __divss\\n\"", "\"\\t.extern __divus\\n\"", "\"\\t.extern __quoss\\n\"", "\"\\t.extern __quous\\n\"", "1", "0", "0", "4", "100" ]

[]

[ "<s>", "void", "maybe_unlink", "(", "const", "char", "*", "file", ")", "{", "if", "(", "debug", ")", "notice", "(", "\"[Leaving %s]\\n\"", ",", "file", ")", ";", "else", "unlink_if_ordinary", "(", "file", ")", ";", "}", "</s>" ]

[ "Unlink", "a", "temporary", "file", "unless", "requested", "otherwise", "." ]

[ "i386", "\"[Leaving %s]\\n\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isMulAddWithConstProfitable", "(", "SDValue", "AddNode", ",", "SDValue", "ConstNode", ")", "const", "{", "const", "EVT", "VT", "=", "AddNode", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getScalarSizeInBits", "(", ")", ">", "32", ")", "return", "true", ";", "const", "ConstantSDNode", "*", "C0Node", "=", "cast", "<", "ConstantSDNode", ">", "(", "AddNode", ".", "getOperand", "(", "1", ")", ")", ";", "const", "ConstantSDNode", "*", "C1Node", "=", "cast", "<", "ConstantSDNode", ">", "(", "ConstNode", ")", ";", "const", "int64_t", "C0", "=", "C0Node", "->", "getSExtValue", "(", ")", ";", "APInt", "CA", "=", "C0Node", "->", "getAPIntValue", "(", ")", "*", "C1Node", "->", "getAPIntValue", "(", ")", ";", "if", "(", "!", "isLegalAddImmediate", "(", "C0", ")", "||", "isLegalAddImmediate", "(", "CA", ".", "getSExtValue", "(", ")", ")", ")", "return", "true", ";", "if", "(", "ConstantMaterializationCost", "(", "(", "unsigned", ")", "CA", ".", "getZExtValue", "(", ")", ",", "Subtarget", ")", ">", "1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "may", "be", "profitable", "to", "transform", "(", "mul", "(", "add", "x", ",", "c1", ")", ",", "c2", ")", "-", ">", "(", "add", "(", "mul", "x", ",", "c2", ")", ",", "c1", "*", "c2", ")", "." ]

[ "ARM", "ARM", "32", "1", "1" ]

[]

[ "<s>", "unsigned", "SparcRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the frame register\"", ")", ";", "return", "SP", "::", "G1", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Sparc", "Sparc", "0", "\"What is the frame register\"", "SP::G1" ]

[]

[ "<s>", "int", "c4x_rptb_nop_p", "(", "rtx", "insn", ")", "{", "rtx", "start_label", ";", "int", "i", ";", "start_label", "=", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ",", "1", ")", ",", "0", ")", ";", "do", "{", "insn", "=", "previous_insn", "(", "insn", ")", ";", "}", "while", "(", "GET_CODE", "(", "insn", ")", "==", "NOTE", "||", "GET_CODE", "(", "insn", ")", "==", "USE", "||", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", ")", "return", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "while", "(", "GET_CODE", "(", "insn", ")", "==", "NOTE", "||", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", "||", "GET_CODE", "(", "insn", ")", "==", "USE", "||", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", ")", "{", "if", "(", "insn", "==", "start_label", ")", "return", "i", "==", "0", ";", "insn", "=", "previous_insn", "(", "insn", ")", ";", "}", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "return", "1", ";", "insn", "=", "previous_insn", "(", "insn", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "The", "last", "instruction", "in", "a", "repeat", "block", "can", "not", "be", "a", "Bcond", ",", "DBcound", ",", "CALL", ",", "CALLCond", ",", "TRAPcond", ",", "RETIcond", ",", "RETScond", ",", "IDLE", ",", "RPTB", "or", "RPTS", ".", "None", "of", "the", "last", "four", "instructions", "from", "the", "bottom", "of", "the", "block", "can", "be", "a", "BcondD", ",", "BRD", ",", "DBcondD", ",", "RPTBD", ",", "LAJ", ",", "LAJcond", ",", "LATcond", ",", "BcondAF", ",", "BcondAT", "or", "RETIcondD", ".", "This", "routine", "scans", "the", "four", "previous", "insns", "for", "a", "jump", "insn", ",", "and", "if", "one", "is", "found", ",", "returns", "1", "so", "that", "we", "bung", "in", "a", "nop", "instruction", ".", "This", "simple", "minded", "strategy", "will", "add", "a", "nop", ",", "when", "it", "may", "not", "be", "required", ".", "Say", "when", "there", "is", "a", "JUMP_INSN", "near", "the", "end", "of", "the", "block", "that", "does", "n't", "get", "converted", "into", "a", "delayed", "branch", ".", "Note", "that", "we", "can", "not", "have", "a", "call", "insn", ",", "since", "we", "do", "n't", "generate", "repeat", "loops", "with", "calls", "in", "them", "(", "although", "I", "suppose", "we", "could", ",", "but", "there", "'s", "no", "benefit", ".", ")", "!", "!", "!", "FIXME", ".", "The", "rptb_top", "insn", "may", "be", "sucked", "into", "a", "SEQUENCE", "." ]

[ "c4x", "0", "0", "1", "0", "1", "0", "4", "0", "1", "0" ]

[]

[ "<s>", "static", "unsigned", "char", "ix86_class_max_nregs", "(", "reg_class_t", "rclass", ",", "machine_mode", "mode", ")", "{", "if", "(", "MAYBE_INTEGER_CLASS_P", "(", "rclass", ")", ")", "{", "if", "(", "mode", "==", "XFmode", ")", "return", "(", "TARGET_64BIT", "?", "2", ":", "3", ")", ";", "else", "if", "(", "mode", "==", "XCmode", ")", "return", "(", "TARGET_64BIT", "?", "4", ":", "6", ")", ";", "else", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "}", "else", "{", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "return", "2", ";", "else", "return", "1", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_CLASS_MAX_NREGS", "hook", ".", "On", "the", "80386", ",", "this", "is", "the", "size", "of", "MODE", "in", "words", ",", "except", "in", "the", "FP", "regs", ",", "where", "a", "single", "reg", "is", "always", "enough", "." ]

[ "i386", "2", "3", "4", "6", "1", "2", "1" ]

[]

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

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

[ "mproc", "mproc", "0" ]

[]

[ "<s>", "bool", "ARMBlockPlacement", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "ST", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "ST", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Running on \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "MF", ")", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "BBUtils", "->", "adjustBBOffsetsAfter", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "ML", ":", "*", "MLI", ")", "{", "MachineBasicBlock", "*", "Preheader", "=", "ML", "->", "getLoopPredecessor", "(", ")", ";", "if", "(", "!", "Preheader", ")", "continue", ";", "for", "(", "auto", "&", "Terminator", ":", "Preheader", "->", "terminators", "(", ")", ")", "{", "if", "(", "Terminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2WhileLoopStart", ")", "continue", ";", "MachineBasicBlock", "*", "LoopExit", "=", "Terminator", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "!", "LoopExit", "->", "getPrevNode", "(", ")", ")", "continue", ";", "if", "(", "blockIsBefore", "(", "Preheader", ",", "LoopExit", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Found a backwards WLS from \"", "<<", "Preheader", "->", "getFullName", "(", ")", "<<", "\" to \"", "<<", "LoopExit", "->", "getFullName", "(", ")", "<<", "\"\\n\"", ")", ";", "bool", "CanMove", "=", "true", ";", "for", "(", "auto", "&", "LoopExitTerminator", ":", "LoopExit", "->", "terminators", "(", ")", ")", "{", "if", "(", "LoopExitTerminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2WhileLoopStart", ")", "continue", ";", "MachineBasicBlock", "*", "LoopExit2", "=", "LoopExitTerminator", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "!", "blockIsBefore", "(", "LoopExit2", ",", "LoopExit", ")", "&&", "(", "LoopExit2", "==", "Preheader", "||", "blockIsBefore", "(", "LoopExit2", ",", "Preheader", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Can't move the target block as it would \"", "\"introduce a new backwards WLS branch\\n\"", ")", ";", "CanMove", "=", "false", ";", "break", ";", "}", "}", "if", "(", "CanMove", ")", "{", "for", "(", "auto", "It", "=", "LoopExit", "->", "getIterator", "(", ")", ";", "It", "!=", "Preheader", "->", "getIterator", "(", ")", ";", "It", "++", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "It", ";", "for", "(", "auto", "&", "Terminator", ":", "MBB", "->", "terminators", "(", ")", ")", "{", "if", "(", "Terminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2LoopEndDec", ")", "continue", ";", "MachineBasicBlock", "*", "LETarget", "=", "Terminator", ".", "getOperand", "(", "2", ")", ".", "getMBB", "(", ")", ";", "if", "(", "LETarget", "==", "LoopExit", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Can't move the target block as it would \"", "\"introduce a new forwards LE branch\\n\"", ")", ";", "CanMove", "=", "false", ";", "break", ";", "}", "}", "}", "if", "(", "!", "CanMove", ")", "break", ";", "}", "if", "(", "CanMove", ")", "{", "moveBasicBlock", "(", "LoopExit", ",", "Preheader", ")", ";", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"Running on \"", "\"\\n\"", "ARM", "ARM", "ARM", "ARM::t2WhileLoopStart", "1", "\"Found a backwards WLS from \"", "\" to \"", "\"\\n\"", "ARM::t2WhileLoopStart", "1", "\"Can't move the target block as it would \"", "\"introduce a new backwards WLS branch\\n\"", "ARM::t2LoopEndDec", "2", "\"Can't move the target block as it would \"", "\"introduce a new forwards LE branch\\n\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOperandsVOP3", "(", "MachineRegisterInfo", "&", "MRI", ",", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "int", "VOP3Idx", "[", "3", "]", "=", "{", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ",", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ",", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", "}", ";", "unsigned", "SGPRReg", "=", "findUsedSGPR", "(", "MI", ",", "VOP3Idx", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "3", ";", "++", "i", ")", "{", "int", "Idx", "=", "VOP3Idx", "[", "i", "]", ";", "if", "(", "Idx", "==", "-", "1", ")", "break", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "Idx", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "!", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", "continue", ";", "if", "(", "SGPRReg", "==", "AMDGPU", "::", "NoRegister", "||", "SGPRReg", "==", "MO", ".", "getReg", "(", ")", ")", "{", "SGPRReg", "=", "MO", ".", "getReg", "(", ")", ";", "continue", ";", "}", "legalizeOpWithMove", "(", "MI", ",", "Idx", ")", ";", "}", "}", "</s>" ]

[ "Fix", "operands", "in", "MI", "to", "satisfy", "constant", "bus", "requirements", "." ]

[ "AMDGPU", "SI", "3", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "3", "1", "AMDGPU::NoRegister" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "const", "MachineFunction", "&", "MF", ",", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f16", ":", "return", "Subtarget", ".", "hasStdExtZfh", "(", ")", ";", "case", "MVT", "::", "f32", ":", "return", "Subtarget", ".", "hasStdExtF", "(", ")", ";", "case", "MVT", "::", "f64", ":", "return", "Subtarget", ".", "hasStdExtD", "(", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "RISCV", "RISCV", "MVT::f16", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "bool", "RISCVRedundantCopyElimination", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Changed", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getNegatedExpression", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "LegalOperations", ",", "bool", "ForCodeSize", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "SDValue", "Arg", "=", "isFNEG", "(", "DAG", ",", "Op", ".", "getNode", "(", ")", ",", "Depth", ")", ")", "return", "DAG", ".", "getBitcast", "(", "Op", ".", "getValueType", "(", ")", ",", "Arg", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "SVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ISD", "::", "FMA", ":", "case", "X86ISD", "::", "FMSUB", ":", "case", "X86ISD", "::", "FNMADD", ":", "case", "X86ISD", "::", "FNMSUB", ":", "case", "X86ISD", "::", "FMADD_RND", ":", "case", "X86ISD", "::", "FMSUB_RND", ":", "case", "X86ISD", "::", "FNMADD_RND", ":", "case", "X86ISD", "::", "FNMSUB_RND", ":", "{", "if", "(", "!", "Op", ".", "hasOneUse", "(", ")", "||", "!", "Subtarget", ".", "hasAnyFMA", "(", ")", "||", "!", "isTypeLegal", "(", "VT", ")", "||", "!", "(", "SVT", "==", "MVT", "::", "f32", "||", "SVT", "==", "MVT", "::", "f64", ")", "||", "!", "LegalOperations", ")", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "NewOps", "(", "Op", ".", "getNumOperands", "(", ")", ",", "SDValue", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "3", ";", "++", "i", ")", "{", "char", "V", "=", "isNegatibleForFree", "(", "Op", ".", "getOperand", "(", "i", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", "+", "1", ")", ";", "if", "(", "V", "==", "2", ")", "NewOps", "[", "i", "]", "=", "getNegatedExpression", "(", "Op", ".", "getOperand", "(", "i", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", "+", "1", ")", ";", "}", "bool", "NegA", "=", "!", "!", "NewOps", "[", "0", "]", ";", "bool", "NegB", "=", "!", "!", "NewOps", "[", "1", "]", ";", "bool", "NegC", "=", "!", "!", "NewOps", "[", "2", "]", ";", "unsigned", "NewOpc", "=", "negateFMAOpcode", "(", "Opc", ",", "NegA", "!=", "NegB", ",", "NegC", ",", "true", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Op", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "!", "NewOps", "[", "i", "]", ")", "NewOps", "[", "i", "]", "=", "Op", ".", "getOperand", "(", "i", ")", ";", "return", "DAG", ".", "getNode", "(", "NewOpc", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "NewOps", ")", ";", "}", "}", "return", "TargetLowering", "::", "getNegatedExpression", "(", "Op", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "the", "newly", "negated", "expression", "if", "the", "cost", "is", "not", "expensive", "and", "set", "the", "cost", "in", "Cost", "to", "indicate", "that", "if", "it", "is", "cheaper", "or", "neutral", "to", "do", "the", "negation", "." ]

[ "X86", "X86", "ISD::FMA", "X86ISD::FMSUB", "X86ISD::FNMADD", "X86ISD::FNMSUB", "X86ISD::FMADD_RND", "X86ISD::FMSUB_RND", "X86ISD::FNMADD_RND", "X86ISD::FNMSUB_RND", "MVT::f32", "MVT::f64", "4", "0", "3", "1", "2", "1", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "bool", "shouldExpandVectorDynExt", "(", "SDNode", "*", "N", ")", "{", "SDValue", "Idx", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "UseDivergentRegisterIndexing", "||", "isa", "<", "ConstantSDNode", ">", "(", "Idx", ")", ")", "return", "false", ";", "SDValue", "Vec", "=", "N", "->", "getOperand", "(", "0", ")", ";", "EVT", "VecVT", "=", "Vec", ".", "getValueType", "(", ")", ";", "EVT", "EltVT", "=", "VecVT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "VecSize", "=", "VecVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "EltSize", "=", "EltVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumElem", "=", "VecVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "VecSize", "<=", "64", "&&", "EltSize", "<", "32", ")", "return", "false", ";", "if", "(", "EltSize", "<", "32", ")", "return", "true", ";", "if", "(", "Idx", "->", "isDivergent", "(", ")", ")", "return", "true", ";", "unsigned", "NumInsts", "=", "NumElem", "+", "(", "(", "EltSize", "+", "31", ")", "/", "32", ")", "*", "NumElem", ";", "return", "NumInsts", "<=", "16", ";", "}", "</s>" ]

[ "Check", "if", "EXTRACT_VECTOR_ELT/INSERT_VECTOR_ELT", "(", "<", "n", "x", "e", ">", ",", "var-idx", ")", "should", "be", "expanded", "into", "a", "set", "of", "cmp/select", "instructions", "." ]

[ "AMDGPU", "1", "0", "64", "32", "32", "31", "32", "16" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "RETURN", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "SETCC", ")", "NODE_NAME_CASE", "(", "SETREG", ")", "NODE_NAME_CASE", "(", "FMA_W_CHAIN", ")", "NODE_NAME_CASE", "(", "FMUL_W_CHAIN", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RCP_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "FMUL_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "FFBH_I32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MULHI_U24", ")", "NODE_NAME_CASE", "(", "MULHI_I24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_U24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "EXPORT_DONE", ")", "NODE_NAME_CASE", "(", "R600_EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "NODE_NAME_CASE", "(", "KILL", ")", "NODE_NAME_CASE", "(", "DUMMY_CHAIN", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "SENDMSGHALT", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "R600", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "SetVector", "<", "Function", "*", ">", "Functions", ";", "AnalysisGetter", "AG", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "}", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "*", "TM", ")", ";", "DenseSet", "<", "const", "char", "*", ">", "Allowed", "(", "{", "&", "AAAMDAttributes", "::", "ID", ",", "&", "AAUniformWorkGroupSize", "::", "ID", ",", "&", "AACallEdges", "::", "ID", "}", ")", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "CGUpdater", ",", "&", "Allowed", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAUniformWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "}", "}", "ChangeStatus", "Change", "=", "A", ".", "run", "(", ")", ";", "return", "Change", "==", "ChangeStatus", "::", "CHANGED", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "int", "avr_mul_highpart_cost", "(", "rtx", "x", ",", "int", ")", "{", "if", "(", "AVR_HAVE_MUL", "&&", "LSHIFTRT", "==", "GET_CODE", "(", "x", ")", "&&", "MULT", "==", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "HImode", "==", "mode", "||", "PSImode", "==", "mode", "||", "SImode", "==", "mode", ")", "{", "return", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "}", "return", "10000", ";", "}", "</s>" ]

[ "Cost", "for", "mul", "highpart", ".", "X", "is", "a", "LSHIFTRT", ",", "i.e", ".", "the", "outer", "TRUNCATE", "is", "already", "stripped", "off", "." ]

[ "avr", "0", "1", "2", "10000" ]

[]

[ "<s>", "bool", "rs6000_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ",", "*", "cur_opt", ";", "HOST_WIDE_INT", "prev_flags", ",", "cur_flags", ",", "diff_flags", ";", "HOST_WIDE_INT", "prev_bumask", ",", "cur_bumask", ",", "diff_bumask", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n==================== rs6000_pragma_target_parse\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"args:\"", ")", ";", "rs6000_debug_target_options", "(", "args", ",", "\" \"", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "pop_target", ")", "{", "fprintf", "(", "stderr", ",", "\"pop_target:\\n\"", ")", ";", "debug_tree", "(", "pop_target", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "\"pop_target: <NULL>\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------\\n\"", ")", ";", "}", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "rs6000_cpu_index", "=", "rs6000_tune_index", "=", "-", "1", ";", "if", "(", "!", "rs6000_inner_target_options", "(", "args", ",", "false", ")", "||", "!", "rs6000_option_override_internal", "(", "false", ")", "||", "(", "cur_tree", "=", "build_target_option_node", "(", "&", "global_options", ")", ")", "==", "NULL_TREE", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", "||", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"invalid pragma\\n\"", ")", ";", "return", "false", ";", "}", "}", "target_option_current_node", "=", "cur_tree", ";", "if", "(", "rs6000_target_modify_macros_ptr", ")", "{", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "prev_bumask", "=", "prev_opt", "->", "x_rs6000_builtin_mask", ";", "prev_flags", "=", "prev_opt", "->", "x_rs6000_isa_flags", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "cur_flags", "=", "cur_opt", "->", "x_rs6000_isa_flags", ";", "cur_bumask", "=", "cur_opt", "->", "x_rs6000_builtin_mask", ";", "diff_bumask", "=", "(", "prev_bumask", "^", "cur_bumask", ")", ";", "diff_flags", "=", "(", "prev_flags", "^", "cur_flags", ")", ";", "if", "(", "(", "diff_flags", "!=", "0", ")", "||", "(", "diff_bumask", "!=", "0", ")", ")", "{", "rs6000_target_modify_macros_ptr", "(", "false", ",", "prev_flags", "&", "diff_flags", ",", "prev_bumask", "&", "diff_bumask", ")", ";", "rs6000_target_modify_macros_ptr", "(", "true", ",", "cur_flags", "&", "diff_flags", ",", "cur_bumask", "&", "diff_bumask", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "powerpcspe", "\"\\n==================== rs6000_pragma_target_parse\\n\"", "\"args:\"", "\" \"", "\"\\n\"", "\"pop_target:\\n\"", "\"pop_target: <NULL>\\n\"", "\"--------------------\\n\"", "1", "\"invalid pragma\\n\"", "0", "0" ]

[]