Datasets:

---

docz1105

/

ComBack

like 9

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "static", "bool", "s390_fix_long_loop_prediction", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "code_label", ",", "label_ref", ";", "rtx_insn", "*", "uncond_jump", ";", "rtx_insn", "*", "cur_insn", ";", "rtx", "tmp", ";", "int", "distance", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "||", "!", "set", "||", "SET_DEST", "(", "set", ")", "!=", "pc_rtx", "||", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "!=", "IF_THEN_ELSE", ")", "return", "false", ";", "if", "(", "ANY_RETURN_P", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "&&", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", "==", "pc_rtx", ")", "return", "false", ";", "label_ref", "=", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "==", "LABEL_REF", "?", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ":", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "label_ref", ")", "==", "LABEL_REF", ")", ";", "code_label", "=", "XEXP", "(", "label_ref", ",", "0", ")", ";", "if", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "code_label", ")", ")", "==", "-", "1", "||", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "==", "-", "1", "||", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "code_label", ")", ")", "<", "PREDICT_DISTANCE", ")", ")", "return", "false", ";", "for", "(", "distance", "=", "0", ",", "cur_insn", "=", "PREV_INSN", "(", "insn", ")", ";", "distance", "<", "PREDICT_DISTANCE", "-", "6", ";", "distance", "+=", "get_attr_length", "(", "cur_insn", ")", ",", "cur_insn", "=", "PREV_INSN", "(", "cur_insn", ")", ")", "if", "(", "!", "cur_insn", "||", "JUMP_P", "(", "cur_insn", ")", "||", "LABEL_P", "(", "cur_insn", ")", ")", "return", "false", ";", "rtx_code_label", "*", "new_label", "=", "gen_label_rtx", "(", ")", ";", "uncond_jump", "=", "emit_jump_insn_after", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "code_label", ")", ")", ",", "insn", ")", ";", "emit_label_after", "(", "new_label", ",", "uncond_jump", ")", ";", "tmp", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ";", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", ";", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", "=", "tmp", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "XEXP", "(", "label_ref", ",", "0", ")", "=", "new_label", ";", "JUMP_LABEL", "(", "insn", ")", "=", "new_label", ";", "JUMP_LABEL", "(", "uncond_jump", ")", "=", "code_label", ";", "return", "true", ";", "}", "</s>" ]

[ "On", "z10", "and", "later", "the", "dynamic", "branch", "prediction", "must", "see", "the", "backward", "jump", "within", "a", "certain", "windows", ".", "If", "not", "it", "falls", "back", "to", "the", "static", "prediction", ".", "This", "function", "rearranges", "the", "loop", "backward", "branch", "in", "a", "way", "which", "makes", "the", "static", "prediction", "always", "correct", ".", "The", "function", "returns", "true", "if", "it", "added", "an", "instruction", "." ]

[ "s390", "1", "2", "1", "1", "2", "0", "1", "1", "0", "6", "1", "1", "2", "2", "1", "0" ]

[]

[ "<s>", "bool", "legitimate_la_operand_p", "(", "rtx", "op", ")", "{", "struct", "s390_address", "addr", ";", "if", "(", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "false", ";", "return", "(", "TARGET_64BIT", "||", "addr", ".", "pointer", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "valid", "operand", "for", "the", "LA", "instruction", ".", "In", "31-bit", ",", "we", "need", "to", "prove", "that", "the", "result", "is", "used", "as", "an", "address", ",", "as", "LA", "performs", "only", "a", "31-bit", "addition", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isCheapToSpeculateCtlz", "(", ")", "const", "{", "return", "Subtarget", "->", "hasLZCNT", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "wasm", "::", "ValType", "getType", "(", "const", "TargetRegisterClass", "*", "RC", ")", "{", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "return", "wasm", "::", "ValType", "::", "I32", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "return", "wasm", "::", "ValType", "::", "I64", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "return", "wasm", "::", "ValType", "::", "F32", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "return", "wasm", "::", "ValType", "::", "F64", ";", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "WebAssembly", "wasm::ValType", "WebAssembly::I32RegClass", "wasm::ValType", "WebAssembly::I64RegClass", "wasm::ValType", "WebAssembly::F32RegClass", "wasm::ValType", "WebAssembly::F64RegClass", "wasm::ValType", "\"Unexpected register class\"" ]

[]

[ "<s>", "inline", "static", "const", "char", "*", "getTagName", "(", "TAGS", "tag", ")", "{", "switch", "(", "tag", ")", "{", "default", ":", "return", "\"\"", ";", "case", "PREFIX_SYMBOL", ":", "return", "\"@\"", ";", "case", "AUTOS_LABEL", ":", "return", "\".auto.\"", ";", "case", "FRAME_LABEL", ":", "return", "\".frame.\"", ";", "case", "TEMPS_LABEL", ":", "return", "\".temp.\"", ";", "case", "ARGS_LABEL", ":", "return", "\".args.\"", ";", "case", "RET_LABEL", ":", "return", "\".ret.\"", ";", "case", "LIBCALL", ":", "return", "\".lib.\"", ";", "case", "FRAME_SECTION", ":", "return", "\".frame_section.\"", ";", "case", "AUTOS_SECTION", ":", "return", "\".autos_section.\"", ";", "case", "CODE_SECTION", ":", "return", "\".code_section.\"", ";", "case", "USER_SECTION", ":", "return", "\".user_section.\"", ";", "}", "}", "</s>" ]

[ "Return", "the", "tag", "of", "this", "operand", "bundle", "as", "a", "string", "." ]

[ "PIC16", "\"\"", "\"@\"", "\".auto.\"", "\".frame.\"", "\".temp.\"", "\".args.\"", "\".ret.\"", "\".lib.\"", "\".frame_section.\"", "\".autos_section.\"", "\".code_section.\"", "\".user_section.\"" ]

[]

[ "<s>", "static", "bool", "avr_hard_regno_call_part_clobbered", "(", "unsigned", ",", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "1", "+", "LAST_CALLEE_SAVED_REG", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>" ]

[ "Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "." ]

[ "avr", "0", "1" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "P2" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "FindSwizzleForVectorSlot", "(", "const", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", ">", "&", "IGSrcs", ",", "std", "::", "vector", "<", "R600InstrInfo", "::", "BankSwizzle", ">", "&", "SwzCandidate", ",", "const", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", "&", "TransSrcs", ",", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", ")", "const", "{", "unsigned", "ValidUpTo", "=", "0", ";", "do", "{", "ValidUpTo", "=", "isLegalUpTo", "(", "IGSrcs", ",", "SwzCandidate", ",", "TransSrcs", ",", "TransSwz", ")", ";", "if", "(", "ValidUpTo", "==", "IGSrcs", ".", "size", "(", ")", ")", "return", "true", ";", "}", "while", "(", "NextPossibleSolution", "(", "SwzCandidate", ",", "ValidUpTo", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Enumerate", "all", "possible", "Swizzle", "sequence", "to", "find", "one", "that", "can", "meet", "all", "read", "port", "requirements", "." ]

[ "AMDGPU", "R600", "R600", "R600", "0" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "LiveRegs", ".", "init", "(", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Start X86FixupBWInsts\\n\"", "\"End X86FixupBWInsts\\n\"" ]

[]

[ "<s>", "static", "tree", "rs6000_get_function_versions_dispatcher", "(", "void", "*", "decl", ")", "{", "tree", "fn", "=", "(", "tree", ")", "decl", ";", "struct", "cgraph_node", "*", "node", "=", "NULL", ";", "struct", "cgraph_node", "*", "default_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "node_v", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "first_v", "=", "NULL", ";", "tree", "dispatch_decl", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "default_version_info", "=", "NULL", ";", "gcc_assert", "(", "fn", "!=", "NULL", "&&", "DECL_FUNCTION_VERSIONED", "(", "fn", ")", ")", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_get_function_versions_dispatcher (%s)\\n\"", ",", "get_decl_name", "(", "fn", ")", ")", ";", "node", "=", "cgraph_node", "::", "get", "(", "fn", ")", ";", "gcc_assert", "(", "node", "!=", "NULL", ")", ";", "node_v", "=", "node", "->", "function_version", "(", ")", ";", "gcc_assert", "(", "node_v", "!=", "NULL", ")", ";", "if", "(", "node_v", "->", "dispatcher_resolver", "!=", "NULL", ")", "return", "node_v", "->", "dispatcher_resolver", ";", "first_v", "=", "node_v", ";", "while", "(", "first_v", "->", "prev", "!=", "NULL", ")", "first_v", "=", "first_v", "->", "prev", ";", "default_version_info", "=", "first_v", ";", "while", "(", "default_version_info", "!=", "NULL", ")", "{", "const", "tree", "decl2", "=", "default_version_info", "->", "this_node", "->", "decl", ";", "if", "(", "is_function_default_version", "(", "decl2", ")", ")", "break", ";", "default_version_info", "=", "default_version_info", "->", "next", ";", "}", "if", "(", "default_version_info", "==", "NULL", ")", "return", "NULL", ";", "if", "(", "first_v", "!=", "default_version_info", ")", "{", "default_version_info", "->", "prev", "->", "next", "=", "default_version_info", "->", "next", ";", "if", "(", "default_version_info", "->", "next", ")", "default_version_info", "->", "next", "->", "prev", "=", "default_version_info", "->", "prev", ";", "first_v", "->", "prev", "=", "default_version_info", ";", "default_version_info", "->", "next", "=", "first_v", ";", "default_version_info", "->", "prev", "=", "NULL", ";", "}", "default_node", "=", "default_version_info", "->", "this_node", ";", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "default_node", "->", "decl", ")", ",", "\"%<target_clones%> attribute needs GLIBC (2.23 and newer) that \"", "\"exports hardware capability bits\"", ")", ";", "if", "(", "targetm", ".", "has_ifunc_p", "(", ")", ")", "{", "struct", "cgraph_function_version_info", "*", "it_v", "=", "NULL", ";", "struct", "cgraph_node", "*", "dispatcher_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "dispatcher_version_info", "=", "NULL", ";", "dispatch_decl", "=", "make_dispatcher_decl", "(", "default_node", "->", "decl", ")", ";", "TREE_NOTHROW", "(", "dispatch_decl", ")", "=", "TREE_NOTHROW", "(", "fn", ")", ";", "dispatcher_node", "=", "cgraph_node", "::", "get_create", "(", "dispatch_decl", ")", ";", "gcc_assert", "(", "dispatcher_node", "!=", "NULL", ")", ";", "dispatcher_node", "->", "dispatcher_function", "=", "1", ";", "dispatcher_version_info", "=", "dispatcher_node", "->", "insert_new_function_version", "(", ")", ";", "dispatcher_version_info", "->", "next", "=", "default_version_info", ";", "dispatcher_node", "->", "definition", "=", "1", ";", "it_v", "=", "default_version_info", ";", "while", "(", "it_v", "!=", "NULL", ")", "{", "it_v", "->", "dispatcher_resolver", "=", "dispatch_decl", ";", "it_v", "=", "it_v", "->", "next", ";", "}", "}", "else", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "default_node", "->", "decl", ")", ",", "\"multiversioning needs %<ifunc%> which is not supported \"", "\"on this target\"", ")", ";", "}", "return", "dispatch_decl", ";", "}", "</s>" ]

[ "Make", "a", "dispatcher", "declaration", "for", "the", "multi-versioned", "function", "DECL", ".", "Calls", "to", "DECL", "function", "will", "be", "replaced", "with", "calls", "to", "the", "dispatcher", "by", "the", "front-end", ".", "Returns", "the", "decl", "of", "the", "dispatcher", "function", "." ]

[ "rs6000", "\"rs6000_get_function_versions_dispatcher (%s)\\n\"", "\"%<target_clones%> attribute needs GLIBC (2.23 and newer) that \"", "\"exports hardware capability bits\"", "1", "1", "\"multiversioning needs %<ifunc%> which is not supported \"", "\"on this target\"" ]

[]

[ "<s>", "static", "bool", "r10k_needs_protection_p_1", "(", "rtx", "x", ",", "rtx_insn", "*", "insn", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "{", "rtx", "mem", "=", "*", "iter", ";", "if", "(", "MEM_P", "(", "mem", ")", ")", "{", "if", "(", "(", "MEM_EXPR", "(", "mem", ")", "&&", "MEM_OFFSET_KNOWN_P", "(", "mem", ")", "&&", "r10k_safe_mem_expr_p", "(", "MEM_EXPR", "(", "mem", ")", ",", "MEM_OFFSET", "(", "mem", ")", ")", ")", "||", "r10k_safe_address_p", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "insn", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "else", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "contains", "a", "MEM", "that", "is", "not", "safe", "from", "R10K", "speculation", ".", "INSN", "is", "the", "instruction", "that", "contains", "X", "." ]

[ "mips", "0" ]

[]

[ "<s>", "const", "PPCMCExpr", "*", "PPCMCExpr", "::", "Create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "int", "AssemblerDialect", "=", "Ctx", ".", "getAsmInfo", "(", ")", "->", "getAssemblerDialect", "(", ")", ";", "return", "new", "(", "Ctx", ")", "PPCMCExpr", "(", "Kind", ",", "Expr", ",", "AssemblerDialect", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

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

[]

[ "<s>", "const", "MCExpr", "*", "ARMElfTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "TM", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "ARM", ")", "return", "TargetLoweringObjectFileELF", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "assert", "(", "Encoding", "==", "DW_EH_PE_absptr", "&&", "\"Can handle absptr encoding only\"", ")", ";", "return", "MCSymbolRefExpr", "::", "Create", "(", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ",", "MCSymbolRefExpr", "::", "VK_ARM_TARGET2", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "ARM", "ARM", "ARM", "\"Can handle absptr encoding only\"", "ARM" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::GlobalAddress", "ISD::JumpTable", "ISD::ConstantPool", "\"Should not custom lower this!\"" ]

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "MBlaze", "::", "LWI", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze::LWI", "0" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "FFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "FFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "12", ")", "-", "1", ")", "/", "2", ")", "return", "false", ";", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "ARM", "ARM", "1", "12", "1", "2" ]

[]

[ "<s>", "static", "int", "arm_barrier_cost", "(", "rtx_insn", "*", "insn", ")", "{", "int", "base_cost", "=", "50", ";", "rtx_insn", "*", "next", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "next", "!=", "NULL", "&&", "LABEL_P", "(", "next", ")", ")", "base_cost", "-=", "20", ";", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "CODE_LABEL", ":", "return", "50", ";", "case", "INSN", ":", "case", "CALL_INSN", ":", "return", "base_cost", ";", "case", "JUMP_INSN", ":", "return", "base_cost", "-", "10", ";", "default", ":", "return", "base_cost", "+", "10", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "forcibly", "inserting", "a", "barrier", "after", "INSN", "." ]

[ "arm", "50", "20", "50", "10", "10" ]

[]

[ "<s>", "void", "ix86_emit_fp_unordered_jump", "(", "rtx", "label", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "temp", ";", "emit_insn", "(", "gen_x86_fnstsw_1", "(", "reg", ")", ")", ";", "if", "(", "TARGET_SAHF", "&&", "(", "TARGET_USE_SAHF", "||", "optimize_insn_for_size_p", "(", ")", ")", ")", "{", "emit_insn", "(", "gen_x86_sahf_1", "(", "reg", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_UNORDERED", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_testqi_ext_ccno_0", "(", "reg", ",", "GEN_INT", "(", "0x04", ")", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "temp", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "temp", ")", ";", "emit_jump_insn", "(", "temp", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "10", "/", "100", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "conditional", "jump", "to", "LABEL", ",", "if", "C2", "flag", "in", "FP", "status", "register", "is", "set", "." ]

[ "i386", "0x04", "10", "100" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI insert wait instructions\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI insert wait instructions\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "bool", "aarch64_use_return_insn_p", "(", "void", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "crtl", "->", "profile", ")", "return", "false", ";", "aarch64_layout_frame", "(", ")", ";", "return", "known_eq", "(", "cfun", "->", "machine", "->", "frame", ".", "frame_size", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "we", "can", "use", "a", "simple_return", "insn", ".", "This", "function", "checks", "whether", "the", "callee", "saved", "stack", "is", "empty", ",", "which", "means", "no", "restore", "actions", "are", "need", ".", "The", "pro_and_epilogue", "will", "use", "this", "to", "check", "whether", "shrink-wrapping", "opt", "is", "feasible", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "int", "rx_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "current_length", ")", "{", "rtx", "extend", ",", "mem", ",", "offset", ";", "bool", "zero", ";", "int", "factor", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "current_length", ";", "switch", "(", "INSN_CODE", "(", "insn", ")", ")", "{", "default", ":", "return", "current_length", ";", "case", "CODE_FOR_plussi3_zero_extendhi", ":", "case", "CODE_FOR_andsi3_zero_extendhi", ":", "case", "CODE_FOR_iorsi3_zero_extendhi", ":", "case", "CODE_FOR_xorsi3_zero_extendhi", ":", "case", "CODE_FOR_divsi3_zero_extendhi", ":", "case", "CODE_FOR_udivsi3_zero_extendhi", ":", "case", "CODE_FOR_minussi3_zero_extendhi", ":", "case", "CODE_FOR_smaxsi3_zero_extendhi", ":", "case", "CODE_FOR_sminsi3_zero_extendhi", ":", "case", "CODE_FOR_multsi3_zero_extendhi", ":", "case", "CODE_FOR_comparesi3_zero_extendhi", ":", "zero", "=", "true", ";", "factor", "=", "2", ";", "break", ";", "case", "CODE_FOR_plussi3_sign_extendhi", ":", "case", "CODE_FOR_andsi3_sign_extendhi", ":", "case", "CODE_FOR_iorsi3_sign_extendhi", ":", "case", "CODE_FOR_xorsi3_sign_extendhi", ":", "case", "CODE_FOR_divsi3_sign_extendhi", ":", "case", "CODE_FOR_udivsi3_sign_extendhi", ":", "case", "CODE_FOR_minussi3_sign_extendhi", ":", "case", "CODE_FOR_smaxsi3_sign_extendhi", ":", "case", "CODE_FOR_sminsi3_sign_extendhi", ":", "case", "CODE_FOR_multsi3_sign_extendhi", ":", "case", "CODE_FOR_comparesi3_sign_extendhi", ":", "zero", "=", "false", ";", "factor", "=", "2", ";", "break", ";", "case", "CODE_FOR_plussi3_zero_extendqi", ":", "case", "CODE_FOR_andsi3_zero_extendqi", ":", "case", "CODE_FOR_iorsi3_zero_extendqi", ":", "case", "CODE_FOR_xorsi3_zero_extendqi", ":", "case", "CODE_FOR_divsi3_zero_extendqi", ":", "case", "CODE_FOR_udivsi3_zero_extendqi", ":", "case", "CODE_FOR_minussi3_zero_extendqi", ":", "case", "CODE_FOR_smaxsi3_zero_extendqi", ":", "case", "CODE_FOR_sminsi3_zero_extendqi", ":", "case", "CODE_FOR_multsi3_zero_extendqi", ":", "case", "CODE_FOR_comparesi3_zero_extendqi", ":", "zero", "=", "true", ";", "factor", "=", "1", ";", "break", ";", "case", "CODE_FOR_plussi3_sign_extendqi", ":", "case", "CODE_FOR_andsi3_sign_extendqi", ":", "case", "CODE_FOR_iorsi3_sign_extendqi", ":", "case", "CODE_FOR_xorsi3_sign_extendqi", ":", "case", "CODE_FOR_divsi3_sign_extendqi", ":", "case", "CODE_FOR_udivsi3_sign_extendqi", ":", "case", "CODE_FOR_minussi3_sign_extendqi", ":", "case", "CODE_FOR_smaxsi3_sign_extendqi", ":", "case", "CODE_FOR_sminsi3_sign_extendqi", ":", "case", "CODE_FOR_multsi3_sign_extendqi", ":", "case", "CODE_FOR_comparesi3_sign_extendqi", ":", "zero", "=", "false", ";", "factor", "=", "1", ";", "break", ";", "}", "extend", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "extend", "!=", "NULL_RTX", ")", ";", "extend", "=", "SET_SRC", "(", "extend", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "extend", ",", "0", ")", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "XEXP", "(", "extend", ",", "0", ")", ")", "==", "SIGN_EXTEND", ")", "extend", "=", "XEXP", "(", "extend", ",", "0", ")", ";", "else", "extend", "=", "XEXP", "(", "extend", ",", "1", ")", ";", "gcc_assert", "(", "(", "zero", "&&", "(", "GET_CODE", "(", "extend", ")", "==", "ZERO_EXTEND", ")", ")", "||", "(", "!", "zero", "&&", "(", "GET_CODE", "(", "extend", ")", "==", "SIGN_EXTEND", ")", ")", ")", ";", "mem", "=", "XEXP", "(", "extend", ",", "0", ")", ";", "gcc_checking_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ")", "return", "(", "zero", "&&", "factor", "==", "1", ")", "?", "2", ":", "3", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "PLUS", ")", ";", "gcc_checking_assert", "(", "REG_P", "(", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ")", ")", ")", ";", "offset", "=", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "1", ")", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "offset", ")", "==", "CONST_INT", ")", ";", "if", "(", "IN_RANGE", "(", "INTVAL", "(", "offset", ")", ",", "0", ",", "255", "*", "factor", ")", ")", "return", "(", "zero", "&&", "factor", "==", "1", ")", "?", "3", ":", "4", ";", "return", "(", "zero", "&&", "factor", "==", "1", ")", "?", "4", ":", "5", ";", "}", "</s>" ]

[ "Compute", "the", "real", "length", "of", "the", "extending", "load-and-op", "instructions", "." ]

[ "rx", "2", "2", "1", "1", "0", "0", "0", "1", "0", "0", "1", "2", "3", "0", "0", "0", "0", "1", "0", "255", "1", "3", "4", "1", "4", "5" ]

[]

[ "<s>", "bool", "nios2_large_constant_memory_operand_p", "(", "rtx", "x", ")", "{", "rtx", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "(", "nios2_large_constant_p", "(", "addr", ")", "||", "nios2_plus_large_constant_p", "(", "addr", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "MEM", "whose", "address", "expression", "involves", "a", "large", "(", "32-bit", ")", "constant", "." ]

[ "nios2", "0" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "getStackSlotRange", "(", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "SubIdx", ",", "unsigned", "&", "Size", ",", "unsigned", "&", "Offset", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Size", "=", "4", ";", "Offset", "=", "0", ";", "return", "true", ";", "}", "</s>" ]

[ "Compute", "the", "size", "in", "bytes", "and", "offset", "within", "a", "stack", "slot", "of", "a", "spilled", "register", "or", "subregister", "." ]

[ "M68k", "M68k", "4", "0" ]

[]

[ "<s>", "const", "PIC16TargetObjectFile", "&", "getObjFileLowering", "(", ")", "const", "{", "return", "(", "const", "PIC16TargetObjectFile", "&", ")", "AsmPrinter", "::", "getObjFileLowering", "(", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "ExtraSteps", ")", "const", "{", "if", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Enabled", ")", "if", "(", "SDValue", "Estimate", "=", "getEstimate", "(", "Subtarget", ",", "AArch64ISD", "::", "FRECPE", ",", "Operand", ",", "DAG", ",", "ExtraSteps", ")", ")", "{", "SDLoc", "DL", "(", "Operand", ")", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", ";", "Flags", ".", "setUnsafeAlgebra", "(", "true", ")", ";", "for", "(", "int", "i", "=", "ExtraSteps", ";", "i", ">", "0", ";", "--", "i", ")", "{", "SDValue", "Step", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "FRECPS", ",", "DL", ",", "VT", ",", "Operand", ",", "Estimate", ",", "&", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Step", ",", "&", "Flags", ")", ";", "}", "ExtraSteps", "=", "0", ";", "return", "Estimate", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "AArch64", "AArch64", "AArch64ISD::FRECPE", "0", "AArch64ISD::FRECPS", "ISD::FMUL", "0" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "withTargetFlags", "(", "SDValue", "Op", ",", "unsigned", "TF", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "const", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "GA", ")", ",", "GA", "->", "getValueType", "(", "0", ")", ",", "GA", "->", "getOffset", "(", ")", ",", "TF", ")", ";", "if", "(", "const", "BlockAddressSDNode", "*", "BA", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetBlockAddress", "(", "BA", "->", "getBlockAddress", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "0", ",", "TF", ")", ";", "if", "(", "const", "ConstantPoolSDNode", "*", "CP", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetConstantPool", "(", "CP", "->", "getConstVal", "(", ")", ",", "CP", "->", "getValueType", "(", "0", ")", ",", "CP", "->", "getAlign", "(", ")", ",", "CP", "->", "getOffset", "(", ")", ",", "TF", ")", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetExternalSymbol", "(", "ES", "->", "getSymbol", "(", ")", ",", "ES", "->", "getValueType", "(", "0", ")", ",", "TF", ")", ";", "if", "(", "const", "JumpTableSDNode", "*", "JT", "=", "dyn_cast", "<", "JumpTableSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetJumpTable", "(", "JT", "->", "getIndex", "(", ")", ",", "JT", "->", "getValueType", "(", "0", ")", ",", "TF", ")", ";", "llvm_unreachable", "(", "\"Unhandled address SDNode\"", ")", ";", "}", "</s>" ]

[ "}", "Custom", "DAGCombine" ]

[ "VE", "VE", "0", "0", "0", "0", "0", "\"Unhandled address SDNode\"" ]

[]

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

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "SIFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", "&&", "!", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "isEntryFunction", "(", ")", ")", "{", "return", "MFI", ".", "getStackSize", "(", ")", "!=", "0", ";", "}", "return", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "needsStackRealignment", "(", "MF", ")", "||", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "computeKnownBits", "(", "SelectionDAG", "&", "DAG", ",", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ")", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ARMISD", "::", "BFI", ")", "{", "computeKnownBits", "(", "DAG", ",", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "ConstantSDNode", "*", "CI", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "const", "APInt", "&", "Mask", "=", "CI", "->", "getAPIntValue", "(", ")", ";", "KnownZero", "&=", "Mask", ";", "KnownOne", "&=", "Mask", ";", "return", ";", "}", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ARMISD", "::", "CMOV", ")", "{", "APInt", "KZ2", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KO2", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "computeKnownBits", "(", "DAG", ",", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "computeKnownBits", "(", "DAG", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "KZ2", ",", "KO2", ")", ";", "KnownZero", "&=", "KZ2", ";", "KnownOne", "&=", "KO2", ";", "return", ";", "}", "return", "DAG", ".", "computeKnownBits", "(", "Op", ",", "KnownZero", ",", "KnownOne", ")", ";", "}", "</s>" ]

[ "Determine", "which", "bits", "of", "Op", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "Known", "." ]

[ "ARM", "ARMISD::BFI", "0", "2", "ARMISD::CMOV", "0", "0", "1", "2" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "i", ",", "ArgInfos", ",", "OrigArgIndices", ")", ";", "++", "i", ";", "}", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "Ins", ";", "subTargetRegTypeForCallingConv", "(", "MIRBuilder", ",", "ArgInfos", ",", "OrigArgIndices", ",", "[", "&", "]", "(", "ISD", "::", "ArgFlagsTy", "flags", ",", "EVT", "vt", ",", "EVT", "argvt", ",", "bool", "used", ",", "unsigned", "origIdx", ",", "unsigned", "partOffs", ")", "{", "Ins", ".", "emplace_back", "(", "flags", ",", "vt", ",", "argvt", ",", "used", ",", "origIdx", ",", "partOffs", ")", ";", "}", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "const", "MipsTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "MipsABIInfo", "&", "ABI", "=", "TM", ".", "getABI", "(", ")", ";", "CCInfo", ".", "AllocateStack", "(", "ABI", ".", "GetCalleeAllocdArgSizeInBytes", "(", "F", ".", "getCallingConv", "(", ")", ")", ",", "1", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "TLI", ".", "CCAssignFnForCall", "(", ")", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Ins", ")", ";", "IncomingValueHandler", "Handler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ")", ";", "if", "(", "!", "Handler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "8", "8", "0", "ISD::InputArg", "8", "ISD::ArgFlagsTy", "16", "Mips", "Mips", "Mips", "Mips", "1" ]

[]

[ "<s>", "void", "ix86_split_fp_branch", "(", "enum", "rtx_code", "code", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "target1", ",", "rtx", "target2", ",", "rtx", "tmp", ")", "{", "rtx", "condition", ";", "rtx", "i", ";", "if", "(", "target2", "!=", "pc_rtx", ")", "{", "std", "::", "swap", "(", "target1", ",", "target2", ")", ";", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "}", "condition", "=", "ix86_expand_fp_compare", "(", "code", ",", "op1", ",", "op2", ",", "tmp", ")", ";", "i", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition", ",", "target1", ",", "target2", ")", ")", ")", ";", "if", "(", "split_branch_probability", ">=", "0", ")", "add_int_reg_note", "(", "i", ",", "REG_BR_PROB", ",", "split_branch_probability", ")", ";", "}", "</s>" ]

[ "Split", "branch", "based", "on", "floating", "point", "condition", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "pa_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "from", "==", "to", ")", "return", "false", ";", "if", "(", "COMPLEX_MODE_P", "(", "from", ")", "||", "VECTOR_MODE_P", "(", "from", ")", "||", "COMPLEX_MODE_P", "(", "to", ")", "||", "VECTOR_MODE_P", "(", "to", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "GET_MODE_SIZE", "(", "to", ")", ")", "return", "false", ";", "if", "(", "MAYBE_FP_REG_CLASS_P", "(", "rclass", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "to", ")", ">", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "to", ")", ">", "GET_MODE_SIZE", "(", "from", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "change", "from", "mode", "FROM", "to", "mode", "TO", "for", "a", "register", "in", "register", "class", "RCLASS", "is", "invalid", "." ]

[ "pa" ]

[]

[ "<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", ";", "RevertedWhileLoops", ".", "clear", "(", ")", ";", "for", "(", "auto", "*", "ML", ":", "*", "MLI", ")", "Changed", "|=", "processPostOrderLoops", "(", "ML", ")", ";", "for", "(", "auto", "*", "WlsInstr", ":", "RevertedWhileLoops", ")", "Changed", "|=", "revertWhileToDoLoop", "(", "WlsInstr", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "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", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "MSP430::FPW", "MSP430::SPW", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]

[]

[ "<s>", "static", "__inline", "unsigned", "long", "long", "sh_media_LDHI_L", "(", "void", "*", "p", ",", "int", "s", ")", "{", "return", "__builtin_sh_media_LDHI_L", "(", "(", "char", "*", ")", "p", "+", "s", ")", ";", "}", "</s>" ]

[ "Misaligned", "Access", "Support", "intrinsics" ]

[ "sh" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "static", "void", "avr_asm_function_begin_epilogue", "(", "FILE", "*", "file", ")", "{", "app_disable", "(", ")", ";", "fprintf", "(", "file", ",", "\"/* epilogue start */\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ASM_FUNCTION_BEGIN_EPILOGUE", "'", "." ]

[ "avr", "\"/* epilogue start */\\n\"" ]

[]

[ "<s>", "MVT", "AArch64TargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", "DL", ",", "EVT", ")", "const", "{", "return", "MVT", "::", "i64", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "AArch64", "AArch64", "MVT::i64" ]

[]

[ "<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "rtx", "result", "=", "0", ";", "int", "size", ",", "align", ";", "if", "(", "TARGET_GHS", "&&", "!", "named", ")", "return", "NULL_RTX", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", "<", "1", ")", "return", "0", ";", "if", "(", "type", ")", "align", "=", "TYPE_ALIGN", "(", "type", ")", "/", "BITS_PER_UNIT", ";", "else", "align", "=", "size", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "align", "-", "1", ")", "&", "~", "(", "align", "-", "1", ")", ";", "if", "(", "cum", "->", "nbytes", ">", "4", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "4", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "switch", "(", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", "{", "case", "0", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "6", ")", ";", "break", ";", "case", "1", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "7", ")", ";", "break", ";", "case", "2", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "8", ")", ";", "break", ";", "case", "3", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "9", ")", ";", "break", ";", "default", ":", "result", "=", "0", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "." ]

[ "v850", "0", "1", "0", "1", "1", "4", "0", "4", "0", "0", "6", "1", "7", "2", "8", "3", "9", "0" ]

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW BB#\"", "<<", "BB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", ".", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "postprocessDAG", "(", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ")", "{", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW BB#\"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "8", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"Nonempty unscheduled zone.\"" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "SparcFI", "=", "MF", "->", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "SparcFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "PtrRC", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "&", "SP", "::", "I64RegsRegClass", ":", "&", "SP", "::", "IntRegsRegClass", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "DebugLoc", "dl", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "get", "(", "SP", "::", "GETPCX", ")", ",", "GlobalBaseReg", ")", ";", "SparcFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "0", "SP::I64RegsRegClass", "SP::IntRegsRegClass", "SP::GETPCX", "Sparc" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "OR1K" ]

[]

[ "<s>", "static", "bool", "nios2_in_small_data_p", "(", "const_tree", "exp", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", ")", "{", "if", "(", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "DECL_SECTION_NAME", "(", "exp", ")", ";", "if", "(", "nios2_small_section_name_p", "(", "section", ")", ")", "return", "true", ";", "}", "else", "if", "(", "flexible_array_type_p", "(", "TREE_TYPE", "(", "exp", ")", ")", "&&", "(", "!", "TREE_PUBLIC", "(", "exp", ")", "||", "DECL_EXTERNAL", "(", "exp", ")", ")", ")", "{", "return", "false", ";", "}", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "size", ">", "0", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "size", "<=", "nios2_section_threshold", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "EXP", "should", "be", "placed", "in", "the", "small", "data", "section", "." ]

[ "nios2", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Immed", ")", "const", "{", "if", "(", "Immed", "==", "std", "::", "numeric_limits", "<", "int64_t", ">", "::", "min", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Illegal add imm \"", "<<", "Immed", "<<", "\": avoid UB for INT64_MIN\\n\"", ")", ";", "return", "false", ";", "}", "Immed", "=", "std", "::", "abs", "(", "Immed", ")", ";", "bool", "IsLegal", "=", "(", "(", "Immed", ">>", "12", ")", "==", "0", "||", "(", "(", "Immed", "&", "0xfff", ")", "==", "0", "&&", "Immed", ">>", "24", "==", "0", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Is \"", "<<", "Immed", "<<", "\" legal add imm: \"", "<<", "(", "IsLegal", "?", "\"yes\"", ":", "\"no\"", ")", "<<", "\"\\n\"", ")", ";", "return", "IsLegal", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "AArch64", "AArch64", "\"Illegal add imm \"", "\": avoid UB for INT64_MIN\\n\"", "12", "0", "0xfff", "0", "24", "0", "\"Is \"", "\" legal add imm: \"", "\"yes\"", "\"no\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegRegOnly", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "SelectAddressRegReg", "(", "N", ",", "Base", ",", "Index", ",", "DAG", ")", ")", "return", "true", ";", "int16_t", "imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "(", "!", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", "||", "!", "N", ".", "getOperand", "(", "1", ")", ".", "hasOneUse", "(", ")", "||", "!", "N", ".", "getOperand", "(", "0", ")", ".", "hasOneUse", "(", ")", ")", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "Base", "=", "DAG", ".", "getRegister", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "ZERO8", ":", "PPC", "::", "ZERO", ",", "N", ".", "getValueType", "(", ")", ")", ";", "Index", "=", "N", ";", "return", "true", ";", "}", "</s>" ]

[ "SelectAddressRegRegOnly", "-", "Given", "the", "specified", "addressed", ",", "force", "it", "to", "be", "represented", "as", "an", "indexed", "[", "r+r", "]", "operation", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "0", "0", "1", "PPC", "PPC::ZERO8", "PPC::ZERO" ]

[]

[ "<s>", "static", "X86Operand", "*", "CreateMem", "(", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "bool", "NeedSizeDir", "=", "false", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "Mem", ".", "NeedSizeDir", "=", "NeedSizeDir", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86", "X86" ]

[]

[ "<s>", "static", "void", "s390_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "fndecl", "==", "s390_previous_fndecl", ")", "{", "s390_indirect_branch_settings", "(", "fndecl", ")", ";", "return", ";", "}", "tree", "old_tree", ";", "if", "(", "s390_previous_fndecl", "==", "NULL_TREE", ")", "old_tree", "=", "target_option_current_node", ";", "else", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "s390_previous_fndecl", ")", ")", "old_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "s390_previous_fndecl", ")", ";", "else", "old_tree", "=", "target_option_default_node", ";", "if", "(", "fndecl", "==", "NULL_TREE", ")", "{", "if", "(", "old_tree", "!=", "target_option_current_node", ")", "s390_activate_target_options", "(", "target_option_current_node", ")", ";", "return", ";", "}", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "new_tree", "==", "NULL_TREE", ")", "new_tree", "=", "target_option_default_node", ";", "if", "(", "old_tree", "!=", "new_tree", ")", "s390_activate_target_options", "(", "new_tree", ")", ";", "s390_previous_fndecl", "=", "fndecl", ";", "s390_indirect_branch_settings", "(", "fndecl", ")", ";", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "s390" ]

[]

[ "<s>", "static", "machine_mode", "sparc_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "if", "(", "TARGET_VIS", ")", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "return", "V2SImode", ";", "case", "E_HImode", ":", "return", "V4HImode", ";", "case", "E_QImode", ":", "return", "V8QImode", ";", "default", ":", ";", "}", "return", "word_mode", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "target", "hook", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "unsigned", "int", "rl78_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "rs", "=", "register_sizes", "[", "regno", "]", ";", "if", "(", "rs", "<", "1", ")", "rs", "=", "1", ";", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "rs", "-", "1", ")", "/", "rs", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS", "." ]

[ "rl78", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "loongarch_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ",", "HOST_WIDE_INT", "bytes_per_iter", ")", "{", "rtx_code_label", "*", "label", ";", "rtx", "src_reg", ",", "dest_reg", ",", "final_src", ",", "test", ";", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "bytes_per_iter", ";", "length", "-=", "leftover", ";", "loongarch_adjust_block_mem", "(", "src", ",", "bytes_per_iter", ",", "&", "src_reg", ",", "&", "src", ")", ";", "loongarch_adjust_block_mem", "(", "dest", ",", "bytes_per_iter", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "0", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "loongarch_block_move_straight", "(", "dest", ",", "src", ",", "bytes_per_iter", ")", ";", "loongarch_emit_move", "(", "src_reg", ",", "plus_constant", "(", "Pmode", ",", "src_reg", ",", "bytes_per_iter", ")", ")", ";", "loongarch_emit_move", "(", "dest_reg", ",", "plus_constant", "(", "Pmode", ",", "dest_reg", ",", "bytes_per_iter", ")", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "src_reg", ",", "final_src", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_jump_insn", "(", "gen_cbranchdi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_cbranchsi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "if", "(", "leftover", ")", "loongarch_block_move_straight", "(", "dest", ",", "src", ",", "leftover", ")", ";", "else", "emit_insn", "(", "gen_nop", "(", ")", ")", ";", "}", "</s>" ]

[ "Move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", "using", "a", "loop", "that", "moves", "BYTES_PER_ITER", "bytes", "at", "a", "time", ".", "LENGTH", "must", "be", "at", "least", "BYTES_PER_ITER", ".", "Assume", "that", "the", "memory", "regions", "do", "not", "overlap", "." ]

[ "loongarch", "0", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "ADDIStocHA", ":", "case", "PPC", "::", "ADDIStocHA8", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "XXLEQVOnes", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "case", "PPC", "::", "CRSET", ":", "case", "PPC", "::", "CRUNSET", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::LIS", "PPC::LIS8", "PPC::ADDIStocHA", "PPC::ADDIStocHA8", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::XXLEQVOnes", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES", "PPC::CRSET", "PPC::CRUNSET" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "CI", ",", "unsigned", "IntrID", ")", "const", "{", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "align", "=", "0", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0" ]

[]

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

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

[ "AVR", "AVR::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "rtx", "mips16e_collect_propagate_value", "(", "rtx", "x", ",", "rtx", "*", "reg_values", ")", "{", "x", "=", "avoid_constant_pool_reference", "(", "x", ")", ";", "if", "(", "UNARY_P", "(", "x", ")", ")", "{", "rtx", "x0", "=", "mips16e_collect_propagate_value", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_values", ")", ";", "return", "simplify_gen_unary", "(", "GET_CODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "x0", ",", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "if", "(", "ARITHMETIC_P", "(", "x", ")", ")", "{", "rtx", "x0", "=", "mips16e_collect_propagate_value", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_values", ")", ";", "rtx", "x1", "=", "mips16e_collect_propagate_value", "(", "XEXP", "(", "x", ",", "1", ")", ",", "reg_values", ")", ";", "return", "simplify_gen_binary", "(", "GET_CODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "x0", ",", "x1", ")", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "reg_values", "[", "REGNO", "(", "x", ")", "]", "&&", "!", "rtx_unstable_p", "(", "reg_values", "[", "REGNO", "(", "x", ")", "]", ")", ")", "return", "reg_values", "[", "REGNO", "(", "x", ")", "]", ";", "return", "x", ";", "}", "</s>" ]

[ "Return", "a", "simplified", "form", "of", "X", "using", "the", "register", "values", "in", "REG_VALUES", ".", "REG_VALUES", "[", "R", "]", "is", "the", "last", "value", "assigned", "to", "hard", "register", "R", ",", "or", "null", "if", "R", "has", "not", "been", "modified", ".", "This", "function", "is", "rather", "limited", ",", "but", "is", "good", "enough", "for", "our", "purposes", "." ]

[ "mips", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "3", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "0", "4", "support::little", "3", "8", "0xff" ]

[]

[ "<s>", "void", "clear", "(", ")", "{", "TagStores", ".", "clear", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "static", "void", "aarch64_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "R0_REGNUM", ";", "rtx", "this_rtx", ",", "temp0", ",", "temp1", ",", "addr", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "vcall_offset", "==", "0", ")", "aarch64_add_constant", "(", "Pmode", ",", "this_regno", ",", "IP1_REGNUM", ",", "delta", ")", ";", "else", "{", "gcc_assert", "(", "(", "vcall_offset", "&", "(", "POINTER_BYTES", "-", "1", ")", ")", "==", "0", ")", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP0_REGNUM", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP1_REGNUM", ")", ";", "addr", "=", "this_rtx", ";", "if", "(", "delta", "!=", "0", ")", "{", "if", "(", "delta", ">=", "-", "256", "&&", "delta", "<", "256", ")", "addr", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "this_rtx", ",", "plus_constant", "(", "Pmode", ",", "this_rtx", ",", "delta", ")", ")", ";", "else", "aarch64_add_constant", "(", "Pmode", ",", "this_regno", ",", "IP1_REGNUM", ",", "delta", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_ZERO_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "if", "(", "vcall_offset", ">=", "-", "256", "&&", "vcall_offset", "<", "4096", "*", "POINTER_BYTES", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "{", "aarch64_internal_mov_immediate", "(", "temp1", ",", "GEN_INT", "(", "vcall_offset", ")", ",", "true", ",", "Pmode", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp0", ",", "temp1", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_SIGN_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "NULL_RTX", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "aarch64", "1", "0", "1", "0", "0", "256", "256", "256", "4096", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "void", "th_mempair_prepare_save_restore_operands", "(", "rtx", "operands", "[", "4", "]", ",", "bool", "load_p", ",", "machine_mode", "mode", ",", "int", "regno", ",", "HOST_WIDE_INT", "offset", ",", "int", "regno2", ",", "HOST_WIDE_INT", "offset2", ")", "{", "int", "reg_op", "=", "load_p", "?", "0", ":", "1", ";", "int", "mem_op", "=", "load_p", "?", "1", ":", "0", ";", "rtx", "mem1", "=", "plus_constant", "(", "mode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "mem1", "=", "gen_frame_mem", "(", "mode", ",", "mem1", ")", ";", "rtx", "mem2", "=", "plus_constant", "(", "mode", ",", "stack_pointer_rtx", ",", "offset2", ")", ";", "mem2", "=", "gen_frame_mem", "(", "mode", ",", "mem2", ")", ";", "operands", "[", "reg_op", "]", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "operands", "[", "mem_op", "]", "=", "mem1", ";", "operands", "[", "2", "+", "reg_op", "]", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "operands", "[", "2", "+", "mem_op", "]", "=", "mem2", ";", "}", "</s>" ]

[ "Prepare", "the", "OPERANDS", "array", "to", "emit", "a", "mempair", "instruction", "using", "the", "provided", "information", ".", "No", "checks", "are", "performed", ",", "the", "resulting", "array", "should", "be", "validated", "using", "th_mempair_operands_p", "(", ")", "." ]

[ "riscv", "4", "0", "1", "1", "0", "2", "2" ]

[]

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

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

[ "PTX", "\"PTX Assembly Printer\"" ]

[]

[ "<s>", "void", "i960_initialize", "(", ")", "{", "if", "(", "TARGET_IC_COMPAT2_0", ")", "{", "i960_maxbitalignment", "=", "8", ";", "i960_last_maxbitalignment", "=", "128", ";", "}", "else", "{", "i960_maxbitalignment", "=", "128", ";", "i960_last_maxbitalignment", "=", "8", ";", "}", "}", "</s>" ]

[ "Initialize", "variables", "before", "compiling", "any", "files", "." ]

[ "i960", "8", "128", "128", "8" ]

[]

[ "<s>", "const", "char", "*", "avr_out_round", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "scalar_mode", "mode", "=", "as_a", "<", "scalar_mode", ">", "(", "GET_MODE", "(", "xop", "[", "0", "]", ")", ")", ";", "scalar_int_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "int", "fbit", "=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ";", "double_int", "i_add", "=", "double_int_zero", ".", "set_bit", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ")", ";", "wide_int", "wi_add", "=", "wi", "::", "set_bit_in_zero", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ",", "GET_MODE_PRECISION", "(", "imode", ")", ")", ";", "int", "len_add", "=", "0", ",", "*", "plen_add", "=", "plen", "?", "&", "len_add", ":", "NULL", ";", "int", "len_and", "=", "0", ",", "*", "plen_and", "=", "plen", "?", "&", "len_and", ":", "NULL", ";", "rtx", "xadd", "=", "const_fixed_from_double_int", "(", "i_add", ",", "mode", ")", ";", "rtx", "xpattern", ",", "xsrc", ",", "op", "[", "4", "]", ";", "xsrc", "=", "SIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", "?", "gen_rtx_SS_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ":", "gen_rtx_US_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xop", "[", "0", "]", ",", "xsrc", ")", ";", "op", "[", "0", "]", "=", "xop", "[", "0", "]", ";", "op", "[", "1", "]", "=", "xop", "[", "1", "]", ";", "op", "[", "2", "]", "=", "xadd", ";", "avr_out_plus", "(", "xpattern", ",", "op", ",", "plen_add", ",", "NULL", ",", "false", ")", ";", "avr_asm_len", "(", "\"rjmp 1f\"", "CR_TAB", "\"0:\"", ",", "NULL", ",", "plen_add", ",", "1", ")", ";", "rtx", "xreg", "=", "simplify_gen_subreg", "(", "imode", ",", "xop", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "rtx", "xmask", "=", "immed_wide_int_const", "(", "-", "wi_add", "-", "wi_add", ",", "imode", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xreg", ",", "gen_rtx_AND", "(", "imode", ",", "xreg", ",", "xmask", ")", ")", ";", "op", "[", "0", "]", "=", "xreg", ";", "op", "[", "1", "]", "=", "xreg", ";", "op", "[", "2", "]", "=", "xmask", ";", "op", "[", "3", "]", "=", "gen_rtx_SCRATCH", "(", "QImode", ")", ";", "avr_out_bitop", "(", "xpattern", ",", "op", ",", "plen_and", ")", ";", "avr_asm_len", "(", "\"1:\"", ",", "NULL", ",", "plen", ",", "0", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "len_add", "+", "len_and", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "fixed-point", "rounding", ".", "XOP", "[", "0", "]", "=", "XOP", "[", "1", "]", "is", "the", "operand", "to", "round", ".", "XOP", "[", "2", "]", "is", "the", "rounding", "point", ",", "a", "CONST_INT", ".", "The", "function", "prints", "the", "instruction", "sequence", "if", "PLEN", "=", "NULL", "and", "computes", "the", "length", "in", "words", "of", "the", "sequence", "if", "PLEN", "!", "=", "NULL", ".", "Most", "of", "this", "function", "deals", "with", "preparing", "operands", "for", "calls", "to", "`", "avr_out_plus", "'", "and", "`", "avr_out_bitop", "'", "." ]

[ "avr", "0", "1", "2", "1", "2", "0", "0", "4", "1", "1", "0", "0", "0", "1", "1", "2", "\"rjmp 1f\"", "\"0:\"", "1", "0", "0", "0", "1", "2", "3", "\"1:\"", "0", "\"\"" ]

[]

[ "<s>", "const", "char", "*", "mmix_data_section_asm_op", "(", "void", ")", "{", "return", "\"\\t.data ! mmixal:= 8H LOC 9B\"", ";", "}", "</s>" ]

[ "DATA_SECTION_ASM_OP", "." ]

[ "mmix", "\"\\t.data ! mmixal:= 8H LOC 9B\"" ]

[]

[ "<s>", "SDValue", "PatmosTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Patmos", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "auto", "Opc", "=", "PatmosISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "ISD::OutputArg", "16", "Patmos", "4", "1", "0", "\"Can only return in registers!\"", "1", "PatmosISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDValue", "Callee", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Hexagon", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Hexagon", "Hexagon", "ISD::InputArg", "16", "Hexagon", "0", "1", "2", "0" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "case", "X86", "::", "MOVZX64rr8", ":", "if", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "case", "X86", "::", "MOVZX64rr16", ":", "case", "X86", "::", "MOVSX64rr32", ":", "case", "X86", "::", "MOVZX64rr32", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "0", ")", ";", "break", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "case", "X86", "::", "MOVZX64rr8", ":", "SubIdx", "=", "1", ";", "break", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "case", "X86", "::", "MOVZX64rr16", ":", "SubIdx", "=", "3", ";", "break", ";", "case", "X86", "::", "MOVSX64rr32", ":", "case", "X86", "::", "MOVZX64rr32", ":", "SubIdx", "=", "4", ";", "break", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "X86", "X86", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVZX64rr8", "X86", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVZX64rr16", "X86::MOVSX64rr32", "X86::MOVZX64rr32", "0", "1", "1", "0", "0", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVZX64rr8", "1", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVZX64rr16", "3", "X86::MOVSX64rr32", "X86::MOVZX64rr32", "4" ]

[]

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

[ "Return", "the", "fixed", "registers", "used", "for", "condition", "codes", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "aarch64_gen_unlikely_cbranch", "(", "enum", "rtx_code", "code", ",", "machine_mode", "cc_mode", ",", "rtx", "label_ref", ")", "{", "rtx", "x", ";", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "cc_mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label_ref", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "for", "a", "conditional", "branch", "with", "rtx", "comparison", "CODE", "in", "mode", "CC_MODE", ".", "The", "destination", "of", "the", "unlikely", "conditional", "branch", "is", "LABEL_REF", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "Nyuzi" ]

[]

[ "<s>", "bool", "UPTInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "return", "TargetInstrInfo", "::", "verifyInstruction", "(", "MI", ",", "ErrInfo", ")", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "UPT", "UPT" ]

[]

[ "<s>", "pure_scalable_type_info", "::", "analysis_result", "pure_scalable_type_info", "::", "analyze", "(", "const_tree", "type", ")", "{", "gcc_assert", "(", "pieces", ".", "is_empty", "(", ")", ")", ";", "if", "(", "type", "==", "error_mark_node", ")", "return", "NO_ABI_IDENTITY", ";", "if", "(", "TYPE_SIZE", "(", "type", ")", "&&", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "return", "NO_ABI_IDENTITY", ";", "piece", "p", "=", "{", "}", ";", "if", "(", "aarch64_sve", "::", "builtin_type_p", "(", "type", ",", "&", "p", ".", "num_zr", ",", "&", "p", ".", "num_pr", ")", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE_RAW", "(", "type", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "(", "!", "TARGET_SVE", "||", "aarch64_sve_mode_p", "(", "mode", ")", ")", ")", ";", "p", ".", "mode", "=", "p", ".", "orig_mode", "=", "mode", ";", "add_piece", "(", "p", ")", ";", "return", "IS_PST", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "analyze_array", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "return", "analyze_record", "(", "type", ")", ";", "return", "ISNT_PST", ";", "}", "</s>" ]

[ "Count", "how", "many", "times", "each", "regno", "is", "referenced", "as", "base", "address", "for", "a", "memory", "access", "." ]

[ "aarch64", "aarch64_sve::builtin_type_p" ]

[]

[ "<s>", "void", "HexagonMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "&", "HMB", "=", "const_cast", "<", "MCInst", "&", ">", "(", "MI", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "HMB", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Encoding bundle\\n\"", ";", ")", ";", "State", ".", "Addend", "=", "0", ";", "State", ".", "Extended", "=", "false", ";", "State", ".", "Bundle", "=", "&", "MI", ";", "State", ".", "Index", "=", "0", ";", "size_t", "Last", "=", "HexagonMCInstrInfo", "::", "bundleSize", "(", "HMB", ")", "-", "1", ";", "uint64_t", "Features", "=", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "HMB", ")", ")", "{", "MCInst", "&", "HMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "verifyInstructionPredicates", "(", "HMI", ",", "Features", ")", ";", "EncodeSingleInstruction", "(", "HMI", ",", "OS", ",", "Fixups", ",", "STI", ",", "parseBits", "(", "Last", ",", "HMB", ",", "HMI", ")", ")", ";", "State", ".", "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "HMI", ")", ";", "State", ".", "Addend", "+=", "HEXAGON_INSTR_SIZE", ";", "++", "State", ".", "Index", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"Encoding bundle\\n\"", "0", "0", "Hexagon", "1", "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_mode_ok_uncached", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "last_regno", "=", "regno", "+", "rs6000_hard_regno_nregs", "[", "mode", "]", "[", "regno", "]", "-", "1", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "mode", "==", "OOmode", ")", "return", "(", "TARGET_MMA", "&&", "VSX_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "&", "1", ")", "==", "0", ")", ";", "if", "(", "mode", "==", "XOmode", ")", "return", "(", "TARGET_MMA", "&&", "FP_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "&", "3", ")", "==", "0", ")", ";", "if", "(", "mode", "==", "PTImode", ")", "return", "(", "IN_RANGE", "(", "regno", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", "&&", "IN_RANGE", "(", "last_regno", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", "&&", "(", "(", "regno", "&", "1", ")", "==", "0", ")", ")", ";", "if", "(", "TARGET_VSX", "&&", "VSX_REGNO_P", "(", "regno", ")", "&&", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "VECTOR_ALIGNMENT_P", "(", "mode", ")", "||", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", "||", "mode", "==", "TImode", "||", "(", "TARGET_VADDUQM", "&&", "mode", "==", "V1TImode", ")", ")", ")", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "FP_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "16", "&&", "!", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", ")", "return", "0", ";", "return", "ALTIVEC_REGNO_P", "(", "last_regno", ")", ";", "}", "}", "if", "(", "INT_REGNO_P", "(", "regno", ")", ")", "return", "INT_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "VECTOR_ALIGNMENT_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "mode", "!=", "TDmode", "||", "(", "regno", "%", "2", ")", "==", "0", ")", "&&", "FP_REGNO_P", "(", "last_regno", ")", ")", "return", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "UNITS_PER_FP_WORD", ")", "return", "1", ";", "if", "(", "TARGET_P8_VECTOR", "&&", "(", "mode", "==", "SImode", ")", ")", "return", "1", ";", "if", "(", "TARGET_P9_VECTOR", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "CA_REGNO_P", "(", "regno", ")", ")", "return", "mode", "==", "Pmode", "||", "mode", "==", "SImode", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", "||", "mode", "==", "V1TImode", ")", ";", "return", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "PPCDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "SelectionDAG", "::", "allnodes_iterator", "Position", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "&", "*", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", ")", "continue", ";", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "OR", ":", "Res", "=", "combineToCMPB", "(", "N", ")", ";", "break", ";", "}", "if", "(", "!", "Res", ")", "foldBoolExts", "(", "Res", ",", "N", ")", ";", "if", "(", "Res", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"PPC DAG preprocessing replacing:\\nOld: \"", ")", ";", "LLVM_DEBUG", "(", "N", "->", "dump", "(", "CurDAG", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nNew: \"", ")", ";", "LLVM_DEBUG", "(", "Res", ".", "getNode", "(", ")", "->", "dump", "(", "CurDAG", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Res", ")", ";", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "MadeChange", ")", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "PowerPC", "PPC", "ISD::OR", "\"PPC DAG preprocessing replacing:\\nOld: \"", "\"\\nNew: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "MachineInstr", "*", "MBlazeInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FI", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "MBlaze", "::", "OR", ":", "case", "MBlaze", "::", "ADD", ":", "if", "(", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "MBlaze", "::", "R0", ")", "&&", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", ")", "{", "if", "(", "Ops", "[", "0", "]", "==", "0", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isUndef", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "MBlaze", "::", "SW", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isUndef", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "MBlaze", "::", "LW", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "}", "break", ";", "}", "return", "NewMI", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "1", "MBlaze::OR", "MBlaze::ADD", "0", "2", "2", "MBlaze::R0", "1", "0", "0", "1", "1", "1", "MBlaze::SW", "0", "0", "0", "0", "MBlaze::LW", "0" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "DEBUG", "(", "MI", ".", "print", "(", "errs", "(", ")", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "StackSize", ";", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "assert", "(", "Offset", "%", "4", "==", "0", "&&", "\"Misaligned stack offset\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "Offset", "/=", "4", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "XCore", "::", "GRRegsRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "isImmUs", "(", "Offset", ")", ")", "InsertFPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ")", ";", "else", "InsertFPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ",", "RS", ")", ";", "}", "else", "{", "if", "(", "isImmU16", "(", "Offset", ")", ")", "InsertSPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ")", ";", "else", "InsertSPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ",", "RS", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "0", "\"Unexpected\"", "XCore", "XCore", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "1", "1", "1", "0", "4", "0", "\"Misaligned stack offset\"", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "4", "0", "XCore::GRRegsRegClass", "\"Unexpected register operand\"" ]

[]

[ "<s>", "bool", "aarch64_sve_float_arith_immediate_p", "(", "rtx", "x", ",", "bool", "negate_p", ")", "{", "rtx", "elt", ";", "REAL_VALUE_TYPE", "r", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "||", "GET_CODE", "(", "elt", ")", "!=", "CONST_DOUBLE", ")", "return", "false", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ";", "if", "(", "negate_p", ")", "r", "=", "real_value_negate", "(", "&", "r", ")", ";", "if", "(", "real_equal", "(", "&", "r", ",", "&", "dconst1", ")", ")", "return", "true", ";", "if", "(", "real_equal", "(", "&", "r", ",", "&", "dconsthalf", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "operand", "for", "an", "SVE", "FADD", "or", "FSUB", "instruction", ".", "Negate", "X", "first", "if", "NEGATE_P", "is", "true", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MF", ":", "M", ")", "{", "Changed", "|=", "runOnFunction", "(", "MF", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "DecodeStatus", "RISCVDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "(", "Bytes", "[", "0", "]", "&", "0x3", ")", "==", "0x3", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32 table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRISCV32Only_16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "0x3", "0x3", "4", "0", "support::endian", "\"Trying RISCV32 table :\\n\"", "4", "2", "0", "support::endian", "RISCV::Feature64Bit", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", "RISCV", "2", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", "2" ]

[]

[ "<s>", "int", "m68k_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "(", "m68k_get_function_kind", "(", "current_function_decl", ")", "==", "m68k_fk_interrupt_handler", ")", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "old_reg", "can", "be", "renamed", "to", "register", "new_reg", "." ]

[ "m68k", "0", "1" ]

[]

[ "<s>", "static", "NodeType", "*", "getEntryNode", "(", "const", "PatmosSinglePathInfo", "*", "PSPI", ")", "{", "return", "PSPI", "->", "getRootScope", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "token", "chain", "corresponding", "to", "the", "entry", "of", "the", "function", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "AMDGPULibFuncImpl", "*", "F", ")", "{", "return", "!", "F", "->", "isMangled", "(", ")", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "mep_use_post_modify_for_set_p", "(", "rtx", "set", ",", "rtx", "gpr", ",", "rtx", "offset", ")", "{", "rtx", "*", "reg", ",", "*", "mem", ";", "unsigned", "int", "reg_bytes", ",", "mem_bytes", ";", "machine_mode", "reg_mode", ",", "mem_mode", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "MEM", ")", "{", "mem", "=", "&", "SET_DEST", "(", "set", ")", ";", "reg", "=", "&", "SET_SRC", "(", "set", ")", ";", "}", "else", "{", "reg", "=", "&", "SET_DEST", "(", "set", ")", ";", "mem", "=", "&", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "*", "mem", ")", "==", "SIGN_EXTEND", ")", "mem", "=", "&", "XEXP", "(", "*", "mem", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "*", "reg", ")", "!=", "REG", "||", "!", "LOADABLE_CR_REGNO_P", "(", "REGNO", "(", "*", "reg", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "*", "mem", ")", "!=", "MEM", "||", "!", "rtx_equal_p", "(", "XEXP", "(", "*", "mem", ",", "0", ")", ",", "gpr", ")", ")", "return", "false", ";", "mem_bytes", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "mem", ")", ")", ";", "reg_bytes", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "reg", ")", ")", ";", "if", "(", "INTVAL", "(", "offset", ")", "&", "(", "mem_bytes", "-", "1", ")", ")", "return", "false", ";", "mem_mode", "=", "mode_for_size", "(", "mem_bytes", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "*", "mem", "=", "change_address", "(", "*", "mem", ",", "mem_mode", ",", "NULL", ")", ";", "*", "reg", "=", "shallow_copy_rtx", "(", "*", "reg", ")", ";", "if", "(", "reg", "==", "&", "SET_DEST", "(", "set", ")", "&&", "reg_bytes", "<", "UNITS_PER_WORD", ")", "{", "PUT_MODE", "(", "*", "reg", ",", "SImode", ")", ";", "*", "mem", "=", "gen_rtx_SIGN_EXTEND", "(", "SImode", ",", "*", "mem", ")", ";", "}", "else", "{", "reg_mode", "=", "mode_for_size", "(", "reg_bytes", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "PUT_MODE", "(", "*", "reg", ",", "reg_mode", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "SET", "can", "be", "turned", "into", "a", "post-modify", "load", "or", "store", "that", "adds", "OFFSET", "to", "GPR", ".", "In", "other", "words", ",", "return", "true", "if", "SET", "can", "be", "changed", "into", ":", "(", "parallel", "[", "SET", "(", "set", "GPR", "(", "plus", ":", "SI", "GPR", "OFFSET", ")", ")", "]", ")", ".", "It", "'s", "OK", "to", "change", "SET", "to", "an", "equivalent", "operation", "in", "order", "to", "make", "it", "match", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"J2 Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "J2", "\"J2 Delay Slot Filler\"" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "AMDGPU_KERNEL", ")", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "32", ")", "return", "NumElts", ";", "if", "(", "Size", ">", "32", ")", "return", "NumElts", "*", "(", "(", "Size", "+", "31", ")", "/", "32", ")", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "return", "(", "NumElts", "+", "1", ")", "/", "2", ";", "}", "else", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">", "32", ")", "return", "(", "VT", ".", "getSizeInBits", "(", ")", "+", "31", ")", "/", "32", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "AMDGPU", "SI", "AMDGPU", "32", "32", "31", "32", "16", "1", "2", "32", "31", "32" ]

[]

[ "<s>", "bool", "KudeyarFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "KudeyarMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "KudeyarMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "4", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ">", "1", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "PUSHA", ")", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "MIB", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "unsigned", "Reg", "=", "CSI", "[", "0", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "PUSH_R", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "PUSH_R", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "4", "1", "Kudeyar::PUSHA", "0", "1", "0", "Kudeyar::PUSH_R", "0", "1", "Kudeyar::PUSH_R" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", "&&", "AM", ".", "Scale", ")", "return", "false", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "Ty", "->", "isSized", "(", ")", ")", "{", "uint64_t", "NumBits", "=", "getDataLayout", "(", ")", "->", "getTypeSizeInBits", "(", "Ty", ")", ";", "NumBytes", "=", "NumBits", "/", "8", ";", "if", "(", "!", "isPowerOf2_64", "(", "NumBits", ")", ")", "NumBytes", "=", "0", ";", "}", "if", "(", "!", "AM", ".", "Scale", ")", "{", "int64_t", "Offset", "=", "AM", ".", "BaseOffs", ";", "if", "(", "Offset", ">=", "-", "(", "1LL", "<<", "9", ")", "&&", "Offset", "<=", "(", "1LL", "<<", "9", ")", "-", "1", ")", "return", "true", ";", "unsigned", "shift", "=", "Log2_64", "(", "NumBytes", ")", ";", "if", "(", "NumBytes", "&&", "Offset", ">", "0", "&&", "(", "Offset", "/", "NumBytes", ")", "<=", "(", "1LL", "<<", "12", ")", "-", "1", "&&", "(", "Offset", ">>", "shift", ")", "<<", "shift", "==", "Offset", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "!", "AM", ".", "Scale", "||", "AM", ".", "Scale", "==", "1", "||", "(", "AM", ".", "Scale", ">", "0", "&&", "(", "uint64_t", ")", "AM", ".", "Scale", "==", "NumBytes", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "AArch64", "AArch64", "0", "8", "0", "1LL", "9", "1LL", "9", "1", "0", "1LL", "12", "1", "1", "0" ]

[]

[ "<s>", "int", "xstormy16_splittable_below100_operand", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "MEM_VOLATILE_P", "(", "x", ")", ")", "return", "0", ";", "return", "xstormy16_below100_operand", "(", "x", ",", "mode", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "only", "for", "non-volatile", "MEMs", ",", "for", "patterns", "where", "the", "MEM", "will", "get", "split", "into", "smaller", "sized", "accesses", "." ]

[ "stormy16", "0" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "RETURNADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "Op", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "Op", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSelect", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Custom lowering not defined for operation\"", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalAddress", "ISD::INTRINSIC_W_CHAIN", "ISD::BUILD_VECTOR", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::CONCAT_VECTORS", "ISD::STORE", "ISD::LOAD", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::SELECT", "\"Custom lowering not defined for operation\"" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFAbsFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "VT", "==", "MVT", "::", "f32", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fabs", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

[ "R600", "MVT::f32" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAVX", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "DarwinVers", "(", "0", ")", ",", "stackAlignment", "(", "8", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "Is64Bit", "(", "is64Bit", ")", ",", "TargetType", "(", "isELF", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "CPU", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "}", "else", "{", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "Is64Bit", "&&", "X86SSELevel", "<", "SSE2", ")", "X86SSELevel", "=", "SSE2", ";", "}", "if", "(", "Is64Bit", ")", "{", "HasX86_64", "=", "true", ";", "HasCMov", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "Is64Bit", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "TT", ".", "length", "(", ")", ">", "5", ")", "{", "size_t", "Pos", ";", "if", "(", "(", "Pos", "=", "TT", ".", "find", "(", "\"-darwin\"", ")", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isDarwin", ";", "if", "(", "isdigit", "(", "TT", "[", "Pos", "+", "7", "]", ")", ")", "DarwinVers", "=", "atoi", "(", "&", "TT", "[", "Pos", "+", "7", "]", ")", ";", "else", "DarwinVers", "=", "8", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isELF", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"cygwin\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isCygwin", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"mingw\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isMingw", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"win32\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isWindows", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"windows\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isWindows", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"-cl\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isDarwin", ";", "DarwinVers", "=", "9", ";", "}", "}", "if", "(", "TargetType", "==", "isDarwin", "||", "Is64Bit", ")", "stackAlignment", "=", "16", ";", "if", "(", "StackAlignment", ")", "stackAlignment", "=", "StackAlignment", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "8", "128", "X86", "X86", "X86", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "5", "\"-darwin\"", "7", "7", "8", "\"linux\"", "\"cygwin\"", "\"mingw\"", "\"win32\"", "\"windows\"", "\"-cl\"", "9", "16" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "FISC", "FISC" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "const", "MachineFunction", "&", "MF", ",", "LLT", "Ty", ")", "const", "{", "switch", "(", "Ty", ".", "getScalarSizeInBits", "(", ")", ")", "{", "case", "16", ":", "return", "isFMAFasterThanFMulAndFAdd", "(", "MF", ",", "MVT", "::", "f16", ")", ";", "case", "32", ":", "return", "isFMAFasterThanFMulAndFAdd", "(", "MF", ",", "MVT", "::", "f32", ")", ";", "case", "64", ":", "return", "isFMAFasterThanFMulAndFAdd", "(", "MF", ",", "MVT", "::", "f64", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "16", "MVT::f16", "32", "MVT::f32", "64", "MVT::f64" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "P2Operand", ">", "CreateMem", "(", "unsigned", "Base", ",", "const", "MCExpr", "*", "Off", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "P2Operand", ">", "(", "k_Memory", ")", ";", "Op", "->", "Mem", ".", "Base", "=", "Base", ";", "Op", "->", "Mem", ".", "Off", "=", "Off", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "P2", "P2", "P2" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "assert", "(", "TLI", ".", "getValueType", "(", "AI", "->", "getType", "(", ")", ",", "true", ")", "==", "MVT", "::", "i32", "&&", "\"Alloca should always return a pointer.\"", ")", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "LEA_ADDiu", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "Mips", "Mips", "MVT::i32", "\"Alloca should always return a pointer.\"", "Mips::GPR32RegClass", "Mips::LEA_ADDiu", "0", "0" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "(", "!", "IsMemset", "||", "ZeroMemset", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", "&&", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "bool", "Fast", ";", "if", "(", "Size", ">=", "16", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "v2f64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "v2f64", ";", "}", "else", "if", "(", "Size", ">=", "8", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "8", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Size", ">=", "4", ")", "return", "MVT", "::", "i32", ";", "else", "if", "(", "Size", ">=", "2", ")", "return", "MVT", "::", "i16", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "ARM", "ARM", "16", "16", "MVT::v2f64", "0", "1", "MVT::v2f64", "8", "8", "MVT::f64", "0", "1", "MVT::f64", "4", "MVT::i32", "2", "MVT::i16", "MVT::Other" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "findCommutedOpIndices", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "int", "AltOpc", "=", "PPC", "::", "getAltVSXFMAOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "AltOpc", "==", "-", "1", ")", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "2", ",", "3", ")", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::getAltVSXFMAOpcode", "1", "2", "3" ]

[]

[ "<s>", "virtual", "const", "MCSection", "*", "getExplicitSectionGlobal", "(", "const", "GlobalValue", "*", "GV", ",", "SectionKind", "Kind", ",", "Mangler", "*", "Mang", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "return", "DataSection", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "WDC65816" ]

[]