Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "executePostLayoutBinding", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ")", "override", "{", "}", "</s>" ]

[ "Perform", "any", "late", "binding", "of", "symbols", "(", "for", "example", ",", "to", "assign", "symbol", "indices", "for", "use", "when", "generating", "relocations", ")", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "NVVMReflectEnabled", ")", "return", "false", ";", "if", "(", "F", ".", "getName", "(", ")", "==", "NVVM_REFLECT_FUNCTION", ")", "{", "assert", "(", "F", ".", "isDeclaration", "(", ")", "&&", "\"_reflect function should not have a body\"", ")", ";", "assert", "(", "F", ".", "getReturnType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "\"_reflect's return type should be integer\"", ")", ";", "return", "false", ";", "}", "SmallVector", "<", "Instruction", "*", ",", "4", ">", "ToRemove", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "CallInst", "*", "Call", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "Call", ")", "continue", ";", "Function", "*", "Callee", "=", "Call", "->", "getCalledFunction", "(", ")", ";", "if", "(", "!", "Callee", "||", "(", "Callee", "->", "getName", "(", ")", "!=", "NVVM_REFLECT_FUNCTION", "&&", "Callee", "->", "getIntrinsicID", "(", ")", "!=", "Intrinsic", "::", "nvvm_reflect", ")", ")", "continue", ";", "assert", "(", "Call", "->", "getNumOperands", "(", ")", "==", "2", "&&", "\"Wrong number of operands to __nvvm_reflect function\"", ")", ";", "const", "Value", "*", "Str", "=", "Call", "->", "getArgOperand", "(", "0", ")", ";", "if", "(", "const", "CallInst", "*", "ConvCall", "=", "dyn_cast", "<", "CallInst", ">", "(", "Str", ")", ")", "{", "Str", "=", "ConvCall", "->", "getArgOperand", "(", "0", ")", ";", "}", "assert", "(", "isa", "<", "ConstantExpr", ">", "(", "Str", ")", "&&", "\"Format of __nvvm__reflect function not recognized\"", ")", ";", "const", "ConstantExpr", "*", "GEP", "=", "cast", "<", "ConstantExpr", ">", "(", "Str", ")", ";", "const", "Value", "*", "Sym", "=", "GEP", "->", "getOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "Constant", ">", "(", "Sym", ")", "&&", "\"Format of __nvvm_reflect function not recognized\"", ")", ";", "const", "Value", "*", "Operand", "=", "cast", "<", "Constant", ">", "(", "Sym", ")", "->", "getOperand", "(", "0", ")", ";", "if", "(", "const", "GlobalVariable", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "Operand", ")", ")", "{", "assert", "(", "GV", "->", "hasInitializer", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "Constant", "*", "Initializer", "=", "GV", "->", "getInitializer", "(", ")", ";", "Operand", "=", "Initializer", ";", "}", "assert", "(", "isa", "<", "ConstantDataSequential", ">", "(", "Operand", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "assert", "(", "cast", "<", "ConstantDataSequential", ">", "(", "Operand", ")", "->", "isCString", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "StringRef", "ReflectArg", "=", "cast", "<", "ConstantDataSequential", ">", "(", "Operand", ")", "->", "getAsString", "(", ")", ";", "ReflectArg", "=", "ReflectArg", ".", "substr", "(", "0", ",", "ReflectArg", ".", "size", "(", ")", "-", "1", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg of _reflect : \"", "<<", "ReflectArg", "<<", "\"\\n\"", ")", ";", "int", "ReflectVal", "=", "0", ";", "if", "(", "ReflectArg", "==", "\"__CUDA_FTZ\"", ")", "{", "if", "(", "auto", "*", "Flag", "=", "mdconst", "::", "extract_or_null", "<", "ConstantInt", ">", "(", "F", ".", "getParent", "(", ")", "->", "getModuleFlag", "(", "\"nvvm-reflect-ftz\"", ")", ")", ")", "ReflectVal", "=", "Flag", "->", "getSExtValue", "(", ")", ";", "}", "Call", "->", "replaceAllUsesWith", "(", "ConstantInt", "::", "get", "(", "Call", "->", "getType", "(", ")", ",", "ReflectVal", ")", ")", ";", "ToRemove", ".", "push_back", "(", "Call", ")", ";", "}", "for", "(", "Instruction", "*", "I", ":", "ToRemove", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "ToRemove", ".", "size", "(", ")", ">", "0", ";", "}", "</s>" ]

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

[ "NVPTX", "\"_reflect function should not have a body\"", "\"_reflect's return type should be integer\"", "4", "Intrinsic::nvvm_reflect", "2", "\"Wrong number of operands to __nvvm_reflect function\"", "0", "0", "\"Format of __nvvm__reflect function not recognized\"", "0", "\"Format of __nvvm_reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "\"Format of _reflect function not recognized\"", "\"Format of _reflect function not recognized\"", "0", "1", "\"Arg of _reflect : \"", "\"\\n\"", "0", "\"__CUDA_FTZ\"", "\"nvvm-reflect-ftz\"", "0" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "Func", "=", "&", "F", ";", "return", "ProcessFunction", "(", ")", ";", "}", "</s>" ]

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

[ "JVM" ]

[]

[ "<s>", "void", "XCoreFrameInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "{", "unsigned", "FramePtr", "=", "XCore", "::", "R10", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "SETSP_1r", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "FrameSize", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "report_fatal_error", "(", "\"emitEpilogue Frame size too big: \"", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "if", "(", "FrameSize", ")", "{", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "FPSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "R10", ",", "FPSpillOffset", ",", "dl", ",", "TII", ")", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "if", "(", "restoreLR", "&&", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "!=", "0", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "LRSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "LR", ",", "LRSpillOffset", ",", "dl", ",", "TII", ")", ";", "restoreLR", "=", "false", ";", "}", "if", "(", "restoreLR", ")", "{", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_u6", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_lu6", ")", ";", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "RETSP_u6", ":", "XCore", "::", "RETSP_lu6", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore::R10", "XCore::SETSP_1r", "4", "0", "\"Misaligned frame size\"", "4", "\"emitEpilogue Frame size too big: \"", "XCore", "XCore", "4", "XCore::R10", "0", "4", "XCore::LR", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_parm_start", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "unsigned", "int", "nwords", ")", "{", "unsigned", "int", "align", ";", "align", "=", "rs6000_function_arg_boundary", "(", "mode", ",", "type", ")", "/", "PARM_BOUNDARY", "-", "1", ";", "return", "nwords", "+", "(", "-", "(", "rs6000_parm_offset", "(", ")", "+", "nwords", ")", "&", "align", ")", ";", "}", "</s>" ]

[ "For", "a", "function", "parm", "of", "MODE", "and", "TYPE", ",", "return", "the", "starting", "word", "in", "the", "parameter", "area", ".", "NWORDS", "of", "the", "parameter", "area", "are", "already", "used", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", "->", "hasAVX512", "(", ")", "?", "MVT", "::", "i1", ":", "MVT", "::", "i8", ";", "if", "(", "Subtarget", "->", "hasAVX512", "(", ")", ")", "switch", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "X86", "X86", "MVT::i1", "MVT::i8", "8", "MVT::v8i1", "16", "MVT::v16i1" ]

[]

[ "<s>", "std", "::", "string", "AMDGPUDevice", "::", "getDataLayout", "(", ")", "const", "{", "return", "std", "::", "string", "(", "\"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16\"", "\"-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64\"", "\"-v96:128:128-v128:128:128-v192:256:256-v256:256:256\"", "\"-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n8:16:32:64\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "R600", "\"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16\"", "\"-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64\"", "\"-v96:128:128-v128:128:128-v192:256:256-v256:256:256\"", "\"-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n8:16:32:64\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SparcTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SP", "::", "IntRegsRegClass", ")", ";", "}", "}", "else", "if", "(", "!", "Constraint", ".", "empty", "(", ")", "&&", "Constraint", ".", "size", "(", ")", "<=", "5", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "*", "(", "Constraint", ".", "end", "(", ")", "-", "1", ")", "==", "'}'", ")", "{", "StringRef", "name", "(", "Constraint", ".", "data", "(", ")", "+", "1", ",", "Constraint", ".", "size", "(", ")", "-", "2", ")", ";", "uint64_t", "intVal", "=", "0", ";", "if", "(", "name", ".", "substr", "(", "0", ",", "1", ")", ".", "equals", "(", "\"r\"", ")", "&&", "!", "name", ".", "substr", "(", "1", ")", ".", "getAsInteger", "(", "10", ",", "intVal", ")", "&&", "intVal", "<=", "31", ")", "{", "const", "char", "regTypes", "[", "]", "=", "{", "'g'", ",", "'o'", ",", "'l'", ",", "'i'", "}", ";", "char", "regType", "=", "regTypes", "[", "intVal", "/", "8", "]", ";", "char", "regIdx", "=", "'0'", "+", "(", "intVal", "%", "8", ")", ";", "char", "tmp", "[", "]", "=", "{", "'{'", ",", "regType", ",", "regIdx", ",", "'}'", ",", "0", "}", ";", "std", "::", "string", "newConstraint", "=", "std", "::", "string", "(", "tmp", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "newConstraint", ",", "VT", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "0", "0U", "SP::IntRegsRegClass", "5", "0", "1", "1", "2", "0", "0", "1", "\"r\"", "1", "10", "31", "8", "8", "0" ]

[]

[ "<s>", "const", "char", "*", "output_adjust_stack_and_probe", "(", "rtx", "reg", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "stack_pointer_rtx", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"sub%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "const0_rtx", ";", "output_asm_insn", "(", "\"or%z0\\t{%1, (%0)|DWORD PTR [%0], %1}\"", ",", "xops", ")", ";", "xops", "[", "0", "]", "=", "stack_pointer_rtx", ";", "xops", "[", "1", "]", "=", "reg", ";", "output_asm_insn", "(", "\"cmp%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tjne\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Adjust", "the", "stack", "pointer", "up", "to", "REG", "while", "probing", "it", "." ]

[ "i386", "0", "32", "2", "\"LPSRL\"", "0", "1", "\"sub%z0\\t{%1, %0|%0, %1}\"", "1", "\"or%z0\\t{%1, (%0)|DWORD PTR [%0], %1}\"", "0", "1", "\"cmp%z0\\t{%1, %0|%0, %1}\"", "\"\\tjne\\t\"", "\"\"" ]

[]

[ "<s>", "static", "section", "*", "rs6000_xcoff_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "x", ",", "mode", ")", ")", "return", "toc_section", ";", "else", "return", "read_only_private_data_section", ";", "}", "</s>" ]

[ "Select", "section", "for", "constant", "in", "constant", "pool", ".", "On", "RS/6000", ",", "all", "constants", "are", "in", "the", "private", "read-only", "data", "area", ".", "However", ",", "if", "this", "is", "being", "placed", "in", "the", "TOC", "it", "must", "be", "output", "as", "a", "toc", "entry", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "int", "dispatch_function_versions", "(", "tree", "dispatch_decl", ",", "void", "*", "fndecls_p", ",", "basic_block", "*", "empty_bb", ")", "{", "tree", "default_decl", ";", "gimple", "ifunc_cpu_init_stmt", ";", "gimple_seq", "gseq", ";", "int", "ix", ";", "tree", "ele", ";", "vec", "<", "tree", ">", "*", "fndecls", ";", "unsigned", "int", "num_versions", "=", "0", ";", "unsigned", "int", "actual_versions", "=", "0", ";", "unsigned", "int", "i", ";", "struct", "_function_version_info", "{", "tree", "version_decl", ";", "tree", "predicate_chain", ";", "unsigned", "int", "dispatch_priority", ";", "}", "*", "function_version_info", ";", "gcc_assert", "(", "dispatch_decl", "!=", "NULL", "&&", "fndecls_p", "!=", "NULL", "&&", "empty_bb", "!=", "NULL", ")", ";", "fndecls", "=", "static_cast", "<", "vec", "<", "tree", ">", "*", ">", "(", "fndecls_p", ")", ";", "num_versions", "=", "fndecls", "->", "length", "(", ")", ";", "gcc_assert", "(", "num_versions", ">=", "2", ")", ";", "function_version_info", "=", "(", "struct", "_function_version_info", "*", ")", "XNEWVEC", "(", "struct", "_function_version_info", ",", "(", "num_versions", "-", "1", ")", ")", ";", "default_decl", "=", "(", "*", "fndecls", ")", "[", "0", "]", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "dispatch_decl", ")", ")", ";", "gseq", "=", "bb_seq", "(", "*", "empty_bb", ")", ";", "ifunc_cpu_init_stmt", "=", "gimple_build_call_vec", "(", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_CPU_INIT", "]", ",", "vNULL", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "ifunc_cpu_init_stmt", ")", ";", "gimple_set_bb", "(", "ifunc_cpu_init_stmt", ",", "*", "empty_bb", ")", ";", "set_bb_seq", "(", "*", "empty_bb", ",", "gseq", ")", ";", "pop_cfun", "(", ")", ";", "for", "(", "ix", "=", "1", ";", "fndecls", "->", "iterate", "(", "ix", ",", "&", "ele", ")", ";", "++", "ix", ")", "{", "tree", "version_decl", "=", "ele", ";", "tree", "predicate_chain", "=", "NULL_TREE", ";", "unsigned", "int", "priority", ";", "priority", "=", "get_builtin_code_for_version", "(", "version_decl", ",", "&", "predicate_chain", ")", ";", "if", "(", "predicate_chain", "==", "NULL_TREE", ")", "continue", ";", "function_version_info", "[", "actual_versions", "]", ".", "version_decl", "=", "version_decl", ";", "function_version_info", "[", "actual_versions", "]", ".", "predicate_chain", "=", "predicate_chain", ";", "function_version_info", "[", "actual_versions", "]", ".", "dispatch_priority", "=", "priority", ";", "actual_versions", "++", ";", "}", "qsort", "(", "function_version_info", ",", "actual_versions", ",", "sizeof", "(", "struct", "_function_version_info", ")", ",", "feature_compare", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "actual_versions", ";", "++", "i", ")", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "function_version_info", "[", "i", "]", ".", "version_decl", ",", "function_version_info", "[", "i", "]", ".", "predicate_chain", ",", "*", "empty_bb", ")", ";", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "default_decl", ",", "NULL", ",", "*", "empty_bb", ")", ";", "free", "(", "function_version_info", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "dispatch", "function", "for", "multi-versioned", "functions", ".", "DISPATCH_DECL", "is", "the", "function", "which", "will", "contain", "the", "dispatch", "logic", ".", "FNDECLS", "are", "the", "function", "choices", "for", "dispatch", ",", "and", "is", "a", "tree", "chain", ".", "EMPTY_BB", "is", "the", "basic", "block", "pointer", "in", "DISPATCH_DECL", "in", "which", "the", "dispatch", "code", "is", "generated", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_reg_live_or_pic_offset_p", "(", "int", "reg", ")", "{", "if", "(", "reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "!", "TARGET_SINGLE_PIC_BASE", ")", "{", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", "&&", "(", "crtl", "->", "calls_eh_return", "||", "df_regs_ever_live_p", "(", "reg", ")", "||", "get_pool_size", "(", ")", ")", ")", "return", "true", ";", "if", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "&&", "flag_pic", ")", "return", "true", ";", "}", "return", "(", "(", "crtl", "->", "calls_eh_return", "||", "df_regs_ever_live_p", "(", "reg", ")", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "the", "gp", "REG", "is", "really", "used", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "int", "ix86_widen_mult_cost", "(", "const", "struct", "processor_costs", "*", "cost", ",", "enum", "machine_mode", "mode", ",", "bool", "uns_p", ")", "{", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", ";", "int", "extra_cost", "=", "0", ";", "int", "basic_cost", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "V8HImode", ":", "case", "V16HImode", ":", "if", "(", "!", "uns_p", "||", "mode", "==", "V16HImode", ")", "extra_cost", "=", "cost", "->", "sse_op", "*", "2", ";", "basic_cost", "=", "cost", "->", "mulss", "*", "2", "+", "cost", "->", "sse_op", "*", "4", ";", "break", ";", "case", "V4SImode", ":", "case", "V8SImode", ":", "basic_cost", "=", "cost", "->", "mulss", "*", "2", "+", "cost", "->", "sse_op", "*", "2", ";", "break", ";", "case", "V2DImode", ":", "if", "(", "!", "TARGET_SSE4_1", "&&", "!", "uns_p", ")", "extra_cost", "=", "(", "cost", "->", "mulss", "+", "cost", "->", "addss", "+", "cost", "->", "sse_op", ")", "*", "4", "+", "cost", "->", "sse_op", "*", "2", ";", "case", "V4DImode", ":", "basic_cost", "=", "cost", "->", "mulss", "*", "2", "+", "cost", "->", "sse_op", "*", "4", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "ix86_vec_cost", "(", "mode", ",", "basic_cost", "+", "extra_cost", ")", ";", "}", "</s>" ]

[ "Return", "cost", "of", "vec_widen_", "<", "s", ">", "mult_hi/lo_", "<", "mode", ">", ",", "vec_widen_", "<", "s", ">", "mul_hi/lo_", "<", "mode", ">", "is", "only", "available", "for", "VI124_AVX2", "." ]

[ "i386", "0", "0", "2", "2", "4", "2", "2", "4", "2", "2", "4" ]

[]

[ "<s>", "bool", "MINA32AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "printMINA32Operands", "(", "Operands", ")", ";", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MINA32Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "MINA32", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "MINA32", "\"invalid operand for instruction\"", "\"invalid instruction\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16mr", "0", "MSP430::GR8RegClass", "MSP430::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "rtx", "aarch64_strip_shift", "(", "rtx", "x", ")", "{", "rtx", "op", "=", "x", ";", "if", "(", "(", "GET_CODE", "(", "op", ")", "==", "ASHIFT", "||", "GET_CODE", "(", "op", ")", "==", "ASHIFTRT", "||", "GET_CODE", "(", "op", ")", "==", "LSHIFTRT", "||", "GET_CODE", "(", "op", ")", "==", "ROTATERT", "||", "GET_CODE", "(", "op", ")", "==", "ROTATE", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MULT", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&&", "(", "(", "unsigned", ")", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", ")", "<", "64", ")", "return", "XEXP", "(", "op", ",", "0", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rtx", "cost", "calculation", ".", "Strip", "a", "shift", "expression", "from", "X", ".", "Returns", "the", "inner", "operand", "if", "successful", ",", "or", "the", "original", "expression", "on", "failure", "." ]

[ "aarch64", "1", "0", "1", "1", "64", "0" ]

[]

[ "<s>", "const", "char", "*", "nvptx_section_for_decl", "(", "const_tree", "decl", ")", "{", "bool", "is_const", "=", "(", "CONSTANT_CLASS_P", "(", "decl", ")", "||", "TREE_CODE", "(", "decl", ")", "==", "CONST_DECL", "||", "TREE_READONLY", "(", "decl", ")", ")", ";", "if", "(", "is_const", ")", "return", "\".const\"", ";", "return", "\".global\"", ";", "}", "</s>" ]

[ "Determine", "whether", "DECL", "goes", "into", ".const", "or", ".global", "." ]

[ "nvptx", "\".const\"", "\".global\"" ]

[]

[ "<s>", "BitVector", "VideoCore4RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "VideoCore4", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "VideoCore4", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "VideoCore4", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "VideoCore4", "::", "ESP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "VideoCore4", "::", "R6", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "VideoCore4", "VideoCore4", "VideoCore4::SP", "VideoCore4::PC", "VideoCore4::GP", "VideoCore4::ESP", "VideoCore4::R6" ]

[]

[ "<s>", "TargetPassConfig", "*", "DLXTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PassManager", ")", "{", "return", "new", "DLXPassConfig", "(", "*", "this", ",", "&", "PassManager", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "DLX" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SITargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "FAdd", ":", "{", "Type", "*", "Ty", "=", "RMW", "->", "getType", "(", ")", ";", "if", "(", "Ty", "->", "isHalfTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "!", "Ty", "->", "isFloatTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "AS", "=", "RMW", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "&&", "Subtarget", "->", "hasAtomicFaddInsts", "(", ")", ")", "{", "return", "RMW", "->", "use_empty", "(", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "return", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "Subtarget", "->", "hasLDSFPAtomics", "(", ")", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "default", ":", "break", ";", "}", "return", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "RMW", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

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

[]

[ "<s>", "iterator", "begin", "(", ")", "{", "return", "Blocks", ".", "rbegin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "JVM" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "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>", "unsigned", "GCNSubtarget", "::", "computeOccupancy", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "LDSSize", ",", "unsigned", "NumSGPRs", ",", "unsigned", "NumVGPRs", ")", "const", "{", "unsigned", "Occupancy", "=", "std", "::", "min", "(", "getMaxWavesPerEU", "(", ")", ",", "getOccupancyWithLocalMemSize", "(", "LDSSize", ",", "MF", ".", "getFunction", "(", ")", ")", ")", ";", "if", "(", "NumSGPRs", ")", "Occupancy", "=", "std", "::", "min", "(", "Occupancy", ",", "getOccupancyWithNumSGPRs", "(", "NumSGPRs", ")", ")", ";", "if", "(", "NumVGPRs", ")", "Occupancy", "=", "std", "::", "min", "(", "Occupancy", ",", "getOccupancyWithNumVGPRs", "(", "NumVGPRs", ")", ")", ";", "return", "Occupancy", ";", "}", "</s>" ]

[ "Return", "occupancy", "for", "the", "given", "function", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "Small", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyLocalReference", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "if", "(", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "&&", "(", "GV", "->", "isDeclarationForLinker", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "return", "X86II", "::", "MO_GOTOFF", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_GOTOFF" ]

[]

[ "<s>", "static", "int", "avr_OS_main_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"OS_main\"", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "an", "OS_main", "function", "." ]

[ "avr", "\"OS_main\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v8f32", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v16f32", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "Enabled", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "return", "SDValue", "(", ")", ";", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "1", ";", "unsigned", "Opcode", "=", "VT", "==", "MVT", "::", "v16f32", "?", "X86ISD", "::", "RCP14", ":", "X86ISD", "::", "FRCP", ";", "return", "DAG", ".", "getNode", "(", "Opcode", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Op", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::f32", "MVT::v4f32", "MVT::v8f32", "MVT::v16f32", "MVT::f32", "1", "MVT::v16f32", "X86ISD::RCP14", "X86ISD::FRCP" ]

[]

[ "<s>", "static", "rtx", "arm_function_value", "(", "const_tree", "type", ",", "const_tree", "func", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "int", "unsignedp", "ATTRIBUTE_UNUSED", ";", "rtx", "r", "ATTRIBUTE_UNUSED", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "return", "aapcs_allocate_return_reg", "(", "mode", ",", "type", ",", "func", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "mode", "=", "arm_promote_function_mode", "(", "type", ",", "mode", ",", "&", "unsignedp", ",", "func", ",", "1", ")", ";", "if", "(", "arm_return_in_msb", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "require", "(", ")", ";", "}", "}", "return", "arm_libcall_value_1", "(", "mode", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", "." ]

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

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "Hexagon", "::", "ArchEnum", ">", "CpuTable", "{", "{", "\"hexagonv4\"", ",", "Hexagon", "::", "ArchEnum", "::", "V4", "}", ",", "{", "\"hexagonv5\"", ",", "Hexagon", "::", "ArchEnum", "::", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "Hexagon", "::", "ArchEnum", "::", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "Hexagon", "::", "ArchEnum", "::", "V62", "}", ",", "{", "\"hexagonv65\"", ",", "Hexagon", "::", "ArchEnum", "::", "V65", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseMemOps", "=", "DisableMemOps", "?", "false", ":", "EnableMemOps", ";", "ModeIEEERndNear", "=", "EnableIEEERndNear", ";", "UseBSBScheduling", "=", "hasV60TOps", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "set", "(", "Hexagon", "::", "FeatureDuplex", ",", "false", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "\"hexagonv4\"", "Hexagon::ArchEnum", "\"hexagonv5\"", "Hexagon::ArchEnum", "\"hexagonv55\"", "Hexagon::ArchEnum", "\"hexagonv60\"", "Hexagon::ArchEnum", "\"hexagonv62\"", "Hexagon::ArchEnum", "\"hexagonv65\"", "Hexagon::ArchEnum", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

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

[ "Return", "the", "mask", "used", "by", "this", "recipe", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "mep_reg_set_p", "(", "rtx", "reg", ",", "rtx", "insn", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "FIND_REG_INC_NOTE", "(", "insn", ",", "reg", ")", ")", "return", "true", ";", "insn", "=", "PATTERN", "(", "insn", ")", ";", "}", "if", "(", "GET_CODE", "(", "insn", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "insn", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "insn", ",", "1", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "insn", ",", "0", ")", ")", "==", "REGNO", "(", "XEXP", "(", "insn", ",", "1", ")", ")", ")", "return", "false", ";", "return", "set_of", "(", "reg", ",", "insn", ")", "!=", "NULL_RTX", ";", "}", "</s>" ]

[ "Frame/Epilog/Prolog", "Related", "." ]

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

[]

[ "<s>", "rtx", "aarch64_mask_from_zextract_ops", "(", "rtx", "width", ",", "rtx", "pos", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "width", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "pos", ")", ")", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "UINTVAL", "(", "width", ")", ")", "-", "1", ";", "return", "GEN_INT", "(", "mask", "<<", "UINTVAL", "(", "pos", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "bitmask", "CONST_INT", "to", "select", "the", "bits", "required", "by", "a", "zero", "extract", "operation", "of", "width", "WIDTH", "at", "bit", "position", "POS", "." ]

[ "aarch64", "1", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "MF", ",", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TGSI" ]

[]

[ "<s>", "const", "char", "*", "arc_output_libcall", "(", "const", "char", "*", "fname", ")", "{", "unsigned", "len", "=", "strlen", "(", "fname", ")", ";", "static", "char", "buf", "[", "64", "]", ";", "gcc_assert", "(", "len", "<", "sizeof", "buf", "-", "35", ")", ";", "if", "(", "TARGET_LONG_CALLS_SET", "||", "(", "TARGET_MEDIUM_CALLS", "&&", "arc_ccfsm_cond_exec_p", "(", ")", ")", ")", "{", "if", "(", "flag_pic", ")", "sprintf", "(", "buf", ",", "\"add r12,pcl,@%s-(.&-4)\\n\\tjl%%!%%* [r12]\"", ",", "fname", ")", ";", "else", "sprintf", "(", "buf", ",", "\"jl%%! @%s\"", ",", "fname", ")", ";", "}", "else", "sprintf", "(", "buf", ",", "\"bl%%!%%* @%s\"", ",", "fname", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Output", "a", "library", "call", "to", "a", "function", "called", "FNAME", "that", "has", "been", "arranged", "to", "be", "local", "to", "any", "dso", "." ]

[ "arc", "64", "35", "\"add r12,pcl,@%s-(.&-4)\\n\\tjl%%!%%* [r12]\"", "\"jl%%! @%s\"", "\"bl%%!%%* @%s\"" ]

[]

[ "<s>", "static", "void", "build_v_base", "(", "function_builder", "&", "b", ",", "const", "char", "*", "signature", ",", "const", "function_group_info", "&", "group", ",", "bool", "force_direct_overloads", "=", "false", ")", "{", "build_32_64", "(", "b", ",", "signature", ",", "group", ",", "MODE_u32base", ",", "MODE_u64base", ",", "force_direct_overloads", ")", ";", "}", "</s>" ]

[ "For", "every", "type", "and", "predicate", "combination", "in", "GROUP", ",", "add", "a", "function", "that", "takes", "a", "vector", "base", "address", "and", "no", "displacement", ".", "The", "vector", "base", "has", "the", "same", "element", "size", "as", "the", "first", "type", "suffix", ".", "The", "other", "arguments", "are", "as", "for", "build_all", "." ]

[ "aarch64" ]

[]

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

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

[ "TVM" ]

[]

[ "<s>", "static", "int", "find_unused_clobbered_reg", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "if", "(", "!", "df_regs_ever_live_p", "(", "i", ")", ")", "return", "i", ";", "return", "0", ";", "}", "</s>" ]

[ "Find", "first", "call", "clobbered", "register", "unsused", "in", "a", "function", ".", "This", "could", "be", "used", "as", "base", "register", "in", "a", "leaf", "function", "or", "for", "holding", "the", "return", "address", "before", "epilogue", "." ]

[ "s390", "0", "6", "0" ]

[]

[ "<s>", "static", "bool", "riscv_warn_func_return", "(", "tree", "decl", ")", "{", "return", "!", "riscv_naked_function_p", "(", "decl", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_WARN_FUNC_RETURN", "." ]

[ "riscv" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "legitimate_reload_fp_constant_p", "(", "rtx", "op", ")", "{", "if", "(", "TARGET_Z196", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "s390_float_const_zero_p", "(", "op", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "fp", "operand", "during", "and", "after", "reload", ".", "This", "function", "accepts", "all", "constants", "which", "can", "be", "loaded", "directly", "into", "an", "FPR", "." ]

[ "s390" ]

[]

[ "<s>", "unsigned", "getSubReg", "(", ")", "const", "{", "assert", "(", "isReg", "(", ")", "&&", "\"Wrong CountValue accessor\"", ")", ";", "return", "Contents", ".", "R", ".", "Sub", ";", "}", "</s>" ]

[ "Returns", "the", "physical", "register", "number", "of", "sub-register", "``", "Index", "''", "for", "physical", "register", "RegNo", "." ]

[ "Hexagon", "\"Wrong CountValue accessor\"" ]

[]

[ "<s>", "bool", "FPS", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "FPIsUsed", "=", "false", ";", "assert", "(", "X86", "::", "FP6", "==", "X86", "::", "FP0", "+", "6", "&&", "\"Register enums aren't sorted right!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<=", "6", ";", "++", "i", ")", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "X86", "::", "FP0", "+", "i", ")", ")", "{", "FPIsUsed", "=", "true", ";", "break", ";", "}", "if", "(", "!", "FPIsUsed", ")", "return", "false", ";", "Bundles", "=", "&", "getAnalysis", "<", "EdgeBundles", ">", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bundleCFG", "(", "MF", ")", ";", "StackTop", "=", "0", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "Processed", ";", "MachineBasicBlock", "*", "Entry", "=", "MF", ".", "begin", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "*", "BB", ":", "depth_first_ext", "(", "Entry", ",", "Processed", ")", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "if", "(", "MF", ".", "size", "(", ")", "!=", "Processed", ".", "size", "(", ")", ")", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "if", "(", "Processed", ".", "insert", "(", "BB", ")", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "LiveBundles", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86::FP6", "X86::FP0", "6", "\"Register enums aren't sorted right!\"", "0", "6", "X86::FP0", "0", "8" ]

[]

[ "<s>", "void", "ARCRegisterInfo", "::", "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", "ARCInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "ARCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "ObjSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int", "LocalFrameSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getLocalFrameSize", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MI", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ObjSize : \"", "<<", "ObjSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LocalFrameSize : \"", "<<", "LocalFrameSize", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "LocalFrameSize", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Offset", "=", "StackSize", "+", "Offset", ";", "if", "(", "FrameIndex", ">=", "0", ")", "assert", "(", "(", "Offset", ">=", "0", "&&", "Offset", "<", "StackSize", ")", "&&", "\"SP Offset not in bounds.\"", ")", ";", "}", "else", "{", "if", "(", "FrameIndex", ">=", "0", ")", "{", "assert", "(", "(", "Offset", "<", "0", "&&", "-", "Offset", "<=", "StackSize", ")", "&&", "\"FP Offset not in bounds.\"", ")", ";", "}", "}", "ReplaceFrameIndex", "(", "II", ",", "TII", ",", "Reg", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ",", "StackSize", ",", "ObjSize", ",", "RS", ",", "SPAdj", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "0", "\"Unexpected\"", "ARC", "ARC", "ARC", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"ObjSize : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "\"LocalFrameSize : \"", "\"\\n\"", "1", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0", "ARC::GPR32RegClass", "\"Unexpected register operand\"", "0", "0", "\"SP Offset not in bounds.\"", "0", "0", "\"FP Offset not in bounds.\"" ]

[]

[ "<s>", "bool", "X86LowerTileCopy", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", ".", "begin", "(", ")", ",", "MIE", "=", "MBB", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "!", "MI", ".", "isCopy", "(", ")", ")", "continue", ";", "MachineOperand", "&", "DstMO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "SrcMO", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "Register", "SrcReg", "=", "SrcMO", ".", "getReg", "(", ")", ";", "Register", "DstReg", "=", "DstMO", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "TILERegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "continue", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "Size", "=", "TRI", "->", "getSpillSize", "(", "X86", "::", "TILERegClass", ")", ";", "Align", "Alignment", "=", "TRI", "->", "getSpillAlign", "(", "X86", "::", "TILERegClass", ")", ";", "int", "TileSS", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateSpillStackObject", "(", "Size", ",", "Alignment", ")", ";", "Size", "=", "TRI", "->", "getSpillSize", "(", "X86", "::", "GR64RegClass", ")", ";", "Alignment", "=", "TRI", "->", "getSpillAlign", "(", "X86", "::", "GR64RegClass", ")", ";", "int", "StrideSS", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateSpillStackObject", "(", "Size", ",", "Alignment", ")", ";", "Register", "GR64Cand", "=", "X86", "::", "RAX", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "IMPLICIT_DEF", ")", ",", "GR64Cand", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOV64mr", ")", ")", ",", "StrideSS", ")", ".", "addReg", "(", "GR64Cand", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOV64ri", ")", ",", "GR64Cand", ")", ".", "addImm", "(", "64", ")", ";", "unsigned", "Opc", "=", "X86", "::", "TILESTORED", ";", "MachineInstr", "*", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ")", ",", "TileSS", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "SrcMO", ".", "isKill", "(", ")", ")", ")", ";", "MachineOperand", "&", "MO", "=", "NewMI", "->", "getOperand", "(", "2", ")", ";", "MO", ".", "setReg", "(", "GR64Cand", ")", ";", "MO", ".", "setIsKill", "(", "true", ")", ";", "Opc", "=", "X86", "::", "TILELOADD", ";", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ",", "DstReg", ")", ",", "TileSS", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOV64rm", ")", ",", "GR64Cand", ")", ",", "StrideSS", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "0", "1", "X86::TILERegClass", "X86::TILERegClass", "X86::TILERegClass", "X86::GR64RegClass", "X86::GR64RegClass", "X86::RAX", "X86::IMPLICIT_DEF", "X86::MOV64mr", "X86::MOV64ri", "64", "X86::TILESTORED", "2", "X86::TILELOADD", "X86::MOV64rm" ]

[]

[ "<s>", "static", "const", "char", "*", "getOpcodeName", "(", "unsigned", "Opcode", ")", "{", "const", "char", "*", "Name", "=", "\"<unknown>\"", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "B", ":", "Name", "=", "\"AArch64::B\"", ";", "break", ";", "case", "AArch64", "::", "Bcc", ":", "Name", "=", "\"AArch64::Bcc\"", ";", "break", ";", "case", "AArch64", "::", "BR", ":", "Name", "=", "\"AArch64::BR\"", ";", "break", ";", "case", "AArch64", "::", "BRAA", ":", "Name", "=", "\"AArch64::BRAA\"", ";", "break", ";", "case", "AArch64", "::", "BRAAZ", ":", "Name", "=", "\"AArch64::BRAAZ\"", ";", "break", ";", "case", "AArch64", "::", "BRAB", ":", "Name", "=", "\"AArch64::BRAB\"", ";", "break", ";", "case", "AArch64", "::", "BRABZ", ":", "Name", "=", "\"AArch64::BRABZ\"", ";", "break", ";", "case", "AArch64", "::", "BL", ":", "Name", "=", "\"AArch64::BL\"", ";", "break", ";", "case", "AArch64", "::", "BLR", ":", "Name", "=", "\"AArch64::BLR\"", ";", "break", ";", "case", "AArch64", "::", "BLRAA", ":", "Name", "=", "\"AArch64::BLRAA\"", ";", "break", ";", "case", "AArch64", "::", "BLRAAZ", ":", "Name", "=", "\"AArch64::BLRAAZ\"", ";", "break", ";", "case", "AArch64", "::", "BLRAB", ":", "Name", "=", "\"AArch64::BLRAB\"", ";", "break", ";", "case", "AArch64", "::", "BLRABZ", ":", "Name", "=", "\"AArch64::BLRABZ\"", ";", "break", ";", "case", "AArch64", "::", "CBZW", ":", "Name", "=", "\"AArch64::CBZW\"", ";", "break", ";", "case", "AArch64", "::", "CBZX", ":", "Name", "=", "\"AArch64::CBZX\"", ";", "break", ";", "case", "AArch64", "::", "CBNZW", ":", "Name", "=", "\"AArch64::CBNZW\"", ";", "break", ";", "case", "AArch64", "::", "CBNZX", ":", "Name", "=", "\"AArch64::CBNZX\"", ";", "break", ";", "case", "AArch64", "::", "CCMPWr", ":", "Name", "=", "\"AArch64::CCMPWr\"", ";", "break", ";", "case", "AArch64", "::", "CCMPXr", ":", "Name", "=", "\"AArch64::CCMPXr\"", ";", "break", ";", "case", "AArch64", "::", "G_FCMP", ":", "Name", "=", "\"AArch64::G_FCMP\"", ";", "break", ";", "case", "AArch64", "::", "G_ICMP", ":", "Name", "=", "\"AArch64::G_ICMP\"", ";", "break", ";", "case", "AArch64", "::", "TBZW", ":", "Name", "=", "\"AArch64::TBZW\"", ";", "break", ";", "case", "AArch64", "::", "TBZX", ":", "Name", "=", "\"AArch64::TBZX\"", ";", "break", ";", "case", "AArch64", "::", "TBNZW", ":", "Name", "=", "\"AArch64::TBNZW\"", ";", "break", ";", "case", "AArch64", "::", "TBNZX", ":", "Name", "=", "\"AArch64::TBNZX\"", ";", "break", ";", "case", "AArch64", "::", "RET", ":", "Name", "=", "\"AArch64::RET\"", ";", "break", ";", "case", "AArch64", "::", "RETAA", ":", "Name", "=", "\"AArch64::RETAA\"", ";", "break", ";", "case", "AArch64", "::", "RETAB", ":", "Name", "=", "\"AArch64::RETAB\"", ";", "break", ";", "case", "AArch64", "::", "SVC", ":", "Name", "=", "\"AArch64::SVC\"", ";", "break", ";", "}", "return", "Name", ";", "}", "</s>" ]

[ "Return", "a", "string", "representation", "for", "an", "opcode", "." ]

[ "AArch64", "\"<unknown>\"", "AArch64::B", "\"AArch64::B\"", "AArch64::Bcc", "\"AArch64::Bcc\"", "AArch64::BR", "\"AArch64::BR\"", "AArch64::BRAA", "\"AArch64::BRAA\"", "AArch64::BRAAZ", "\"AArch64::BRAAZ\"", "AArch64::BRAB", "\"AArch64::BRAB\"", "AArch64::BRABZ", "\"AArch64::BRABZ\"", "AArch64::BL", "\"AArch64::BL\"", "AArch64::BLR", "\"AArch64::BLR\"", "AArch64::BLRAA", "\"AArch64::BLRAA\"", "AArch64::BLRAAZ", "\"AArch64::BLRAAZ\"", "AArch64::BLRAB", "\"AArch64::BLRAB\"", "AArch64::BLRABZ", "\"AArch64::BLRABZ\"", "AArch64::CBZW", "\"AArch64::CBZW\"", "AArch64::CBZX", "\"AArch64::CBZX\"", "AArch64::CBNZW", "\"AArch64::CBNZW\"", "AArch64::CBNZX", "\"AArch64::CBNZX\"", "AArch64::CCMPWr", "\"AArch64::CCMPWr\"", "AArch64::CCMPXr", "\"AArch64::CCMPXr\"", "AArch64::G_FCMP", "\"AArch64::G_FCMP\"", "AArch64::G_ICMP", "\"AArch64::G_ICMP\"", "AArch64::TBZW", "\"AArch64::TBZW\"", "AArch64::TBZX", "\"AArch64::TBZX\"", "AArch64::TBNZW", "\"AArch64::TBNZW\"", "AArch64::TBNZX", "\"AArch64::TBNZX\"", "AArch64::RET", "\"AArch64::RET\"", "AArch64::RETAA", "\"AArch64::RETAA\"", "AArch64::RETAB", "\"AArch64::RETAB\"", "AArch64::SVC", "\"AArch64::SVC\"" ]

[]

[ "<s>", "poly_int64", "pdp11_push_rounding", "(", "poly_int64", "bytes", ")", "{", "return", "(", "bytes", "+", "1", ")", "&", "~", "1", ";", "}", "</s>" ]

[ "Implement", "PUSH_ROUNDING", ".", "On", "the", "pdp11", ",", "the", "stack", "is", "on", "an", "even", "boundary", "." ]

[ "pdp11", "1", "1" ]

[]

[ "<s>", "SDNode", "*", "DCPU16DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ")", ";", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "assert", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i16", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i16", ")", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "DCPU16", "::", "ADD16ri", ",", "MVT", "::", "i16", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i16", ")", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "DCPU16", "::", "ADD16ri", ",", "dl", ",", "MVT", "::", "i16", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i16", ")", ")", ";", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "Dcpu16", "DCPU16", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "ISD::FrameIndex", "0", "MVT::i16", "MVT::i16", "DCPU16::ADD16ri", "MVT::i16", "0", "MVT::i16", "DCPU16::ADD16ri", "MVT::i16", "0", "MVT::i16", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isLinux", "(", ")", ")", "return", "false", ";", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getTargetData", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

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

[]

[ "<s>", "void", "bpf_print_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "int", "code", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "op", ")", "==", "VOIDmode", ")", "{", "if", "(", "CONST_DOUBLE_HIGH", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DOUBLE_HEX", ",", "CONST_DOUBLE_HIGH", "(", "op", ")", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "else", "if", "(", "CONST_DOUBLE_LOW", "(", "op", ")", "<", "0", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "else", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "}", "else", "{", "long", "vals", "[", "2", "]", ";", "real_to_target", "(", "vals", ",", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "GET_MODE", "(", "op", ")", ")", ";", "vals", "[", "0", "]", "&=", "0xffffffff", ";", "vals", "[", "1", "]", "&=", "0xffffffff", ";", "if", "(", "GET_MODE", "(", "op", ")", "==", "SFmode", ")", "fprintf", "(", "file", ",", "\"0x%08lx\"", ",", "vals", "[", "0", "]", ")", ";", "else", "if", "(", "GET_MODE", "(", "op", ")", "==", "DFmode", ")", "{", "if", "(", "WORDS_BIG_ENDIAN", ")", "fprintf", "(", "file", ",", "\"0x%08lx%08lx\"", ",", "vals", "[", "0", "]", ",", "vals", "[", "1", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"0x%08lx%08lx\"", ",", "vals", "[", "1", "]", ",", "vals", "[", "0", "]", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "}", "}", "</s>" ]

[ "Print", "an", "instruction", "operand", ".", "This", "function", "is", "called", "in", "the", "macro", "PRINT_OPERAND", "defined", "in", "bpf.h" ]

[ "bpf", "\"%s\"", "0", "0", "2", "0", "0xffffffff", "1", "0xffffffff", "\"0x%08lx\"", "0", "\"0x%08lx%08lx\"", "0", "1", "\"0x%08lx%08lx\"", "1", "0" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", "&", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "os16", "(", ")", ")", "addPass", "(", "createMipsOs16Pass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "inMips16HardFloat", "(", ")", ")", "addPass", "(", "createMips16HardFloatPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "DirectToNaCl", ")", "{", "addPass", "(", "createExpandVarArgsPass", "(", ")", ")", ";", "addPass", "(", "createExpandByValPass", "(", ")", ")", ";", "addPass", "(", "createAddPNaClExternalDeclsPass", "(", ")", ")", ";", "addPass", "(", "createResolvePNaClIntrinsicsPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mandarin", "128" ]

[]

[ "<s>", "SDValue", "TPCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CC", ",", "bool", "Flag", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "Vec", ",", "const", "SDLoc", "&", "Loc", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "TPCISD", "::", "HALT", ",", "Loc", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "ISD::OutputArg", "TPCISD::HALT", "MVT::Other" ]

[]

[ "<s>", "const", "uint16_t", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "uint16_t", "*", "RegList", "=", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "if", "(", "!", "MF", ")", "return", "RegList", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "return", "RegList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Avoid Store Forwarding Blocks\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Avoid Store Forwarding Blocks\"" ]

[]

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

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

[ "M68k", "\"M68k Assembly Printer\"" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X" ]

[]

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

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

[ "SystemZ", "SystemZ", "1", "0" ]

[]

[ "<s>", "static", "bool", "cortex_a9_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep", ",", "int", "*", "cost", ")", "{", "switch", "(", "REG_NOTE_KIND", "(", "link", ")", ")", "{", "case", "REG_DEP_ANTI", ":", "*", "cost", "=", "0", ";", "return", "false", ";", "case", "REG_DEP_TRUE", ":", "case", "REG_DEP_OUTPUT", ":", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "recog_memoized", "(", "dep", ")", ">=", "0", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "==", "MODE_FLOAT", ")", "{", "enum", "attr_type", "attr_type_insn", "=", "get_attr_type", "(", "insn", ")", ";", "enum", "attr_type", "attr_type_dep", "=", "get_attr_type", "(", "dep", ")", ";", "if", "(", "REG_P", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", "&&", "REG_P", "(", "SET_DEST", "(", "PATTERN", "(", "dep", ")", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ",", "SET_DEST", "(", "PATTERN", "(", "dep", ")", ")", ")", ")", "{", "if", "(", "(", "attr_type_insn", "==", "TYPE_FMACS", "||", "attr_type_insn", "==", "TYPE_FMACD", ")", "&&", "(", "attr_type_dep", "==", "TYPE_FMACS", "||", "attr_type_dep", "==", "TYPE_FMACD", ")", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", ")", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", "-", "3", ";", "else", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", ";", "return", "false", ";", "}", "else", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", ")", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", "+", "1", ";", "else", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", ";", "}", "return", "false", ";", "}", "}", "}", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Adjust", "cost", "hook", "for", "Cortex", "A9", "." ]

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

[]

[ "<s>", "void", "altivec_expand_stvx_be", "(", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "mode", ",", "unsigned", "unspec", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "store", "=", "gen_rtx_SET", "(", "op0", ",", "tmp", ")", ";", "rtx", "stvx", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "unspec", ")", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "store", ",", "stvx", ")", ")", ";", "rtx", "sel", "=", "swap_selector_for_mode", "(", "mode", ")", ";", "rtx", "vperm", ";", "gcc_assert", "(", "REG_P", "(", "op1", ")", ")", ";", "vperm", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op1", ",", "sel", ")", ",", "UNSPEC_VPERM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "vperm", ")", ")", ";", "emit_insn", "(", "par", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "a", "``", "stvx", "''", "or", "``", "stvxl", "''", "built-in", "for", "a", "little", "endian", "target", "with", "-maltivec=be", "specified", ".", "Issue", "the", "store", "preceded", "by", "an", "element-reversing", "permute", "." ]

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

[]

[ "<s>", "unsigned", "GCNHazardRecognizer", "::", "PreEmitNoops", "(", "MachineInstr", "*", "MI", ")", "{", "IsHazardRecognizerMode", "=", "true", ";", "CurrCycleInstr", "=", "MI", ";", "unsigned", "W", "=", "PreEmitNoopsCommon", "(", "MI", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "return", "W", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "BitVector", "TeakRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "R7", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "LC", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "EXT0", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "EXT1", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "EXT2", ")", ";", "Reserved", ".", "set", "(", "Teak", "::", "EXT3", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Teak", "Teak", "Teak::SP", "Teak::PC", "Teak::R7", "Teak::LC", "Teak::EXT0", "Teak::EXT1", "Teak::EXT2", "Teak::EXT3" ]

[]

[ "<s>", "static", "int", "zero_all_st_registers", "(", "HARD_REG_SET", "need_zeroed_hardregs", ")", "{", "if", "(", "!", "(", "TARGET_80387", "||", "TARGET_FLOAT_RETURNS_IN_80387", ")", ")", "return", "0", ";", "unsigned", "int", "num_of_st", "=", "0", ";", "for", "(", "unsigned", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "(", "STACK_REGNO_P", "(", "regno", ")", "||", "MMX_REGNO_P", "(", "regno", ")", ")", "&&", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "{", "num_of_st", "++", ";", "break", ";", "}", "if", "(", "num_of_st", "==", "0", ")", "return", "0", ";", "bool", "return_with_x87", "=", "false", ";", "return_with_x87", "=", "(", "crtl", "->", "return_rtx", "&&", "(", "STACK_REG_P", "(", "crtl", "->", "return_rtx", ")", ")", ")", ";", "bool", "complex_return", "=", "false", ";", "complex_return", "=", "(", "crtl", "->", "return_rtx", "&&", "COMPLEX_MODE_P", "(", "GET_MODE", "(", "crtl", "->", "return_rtx", ")", ")", ")", ";", "if", "(", "return_with_x87", ")", "if", "(", "complex_return", ")", "num_of_st", "=", "6", ";", "else", "num_of_st", "=", "7", ";", "else", "num_of_st", "=", "8", ";", "rtx", "st_reg", "=", "gen_rtx_REG", "(", "XFmode", ",", "FIRST_STACK_REG", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "num_of_st", ";", "i", "++", ")", "emit_insn", "(", "gen_rtx_SET", "(", "st_reg", ",", "CONST0_RTX", "(", "XFmode", ")", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "num_of_st", ";", "i", "++", ")", "{", "rtx", "insn", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "st_reg", ",", "st_reg", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_DEAD", ",", "st_reg", ")", ";", "}", "return", "num_of_st", ";", "}", "</s>" ]

[ "Generate", "insns", "to", "zero", "all", "st", "registers", "together", ".", "Return", "true", "when", "zeroing", "instructions", "are", "generated", ".", "Assume", "the", "number", "of", "st", "registers", "that", "are", "zeroed", "is", "num_of_st", ",", "we", "will", "emit", "the", "following", "sequence", "to", "zero", "them", "together", ":", "fldz", ";", "\\", "fldz", ";", "\\", "...", "fldz", ";", "\\", "fstp", "%", "%", "st", "(", "0", ")", ";", "\\", "fstp", "%", "%", "st", "(", "0", ")", ";", "\\", "...", "fstp", "%", "%", "st", "(", "0", ")", ";", "i.e.", ",", "num_of_st", "fldz", "followed", "by", "num_of_st", "fstp", "to", "clear", "the", "stack", "mark", "stack", "slots", "empty", ".", "How", "to", "compute", "the", "num_of_st", ":", "There", "is", "no", "direct", "mapping", "from", "stack", "registers", "to", "hard", "register", "numbers", ".", "If", "one", "stack", "register", "needs", "to", "be", "cleared", ",", "we", "do", "n't", "know", "where", "in", "the", "stack", "the", "value", "remains", ".", "So", ",", "if", "any", "stack", "register", "needs", "to", "be", "cleared", ",", "the", "whole", "stack", "should", "be", "cleared", ".", "However", ",", "x87", "stack", "registers", "that", "hold", "the", "return", "value", "should", "be", "excluded", ".", "x87", "returns", "in", "the", "top", "(", "two", "for", "complex", "values", ")", "register", ",", "so", "num_of_st", "should", "be", "7/6", "when", "x87", "returns", ",", "otherwise", "it", "will", "be", "8", "." ]

[ "i386", "0", "0", "0", "0", "0", "6", "7", "8", "0", "0" ]

[]

[ "<s>", "static", "bool", "decl_has_samegp", "(", "tree", "decl", ")", "{", "if", "(", "!", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "TARGET_SMALL_DATA", ")", "return", "true", ";", "return", "!", "TREE_PUBLIC", "(", "decl", ")", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "DECL", "will", "share", "the", "same", "GP", "as", "any", "function", "in", "the", "current", "unit", "of", "translation", "." ]

[ "alpha" ]

[]

[ "<s>", "void", "SIMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "uint64_t", "Encoding", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "bytes", "=", "Desc", ".", "getSize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "bytes", ";", "i", "++", ")", "{", "OS", ".", "write", "(", "(", "uint8_t", ")", "(", "(", "Encoding", ">>", "(", "8", "*", "i", ")", ")", "&", "0xff", ")", ")", ";", "}", "if", "(", "bytes", ">", "4", ")", "return", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "!", "AMDGPU", "::", "isSISrcOperand", "(", "Desc", ",", "i", ")", ")", "continue", ";", "const", "MCOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "getLitEncoding", "(", "Op", ",", "Desc", ".", "OpInfo", "[", "i", "]", ",", "STI", ")", "!=", "255", ")", "continue", ";", "int64_t", "Imm", "=", "0", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "else", "if", "(", "Op", ".", "isExpr", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "C", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ")", "Imm", "=", "C", "->", "getValue", "(", ")", ";", "}", "else", "if", "(", "!", "Op", ".", "isExpr", "(", ")", ")", "llvm_unreachable", "(", "\"Must be immediate or expr\"", ")", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "4", ";", "j", "++", ")", "{", "OS", ".", "write", "(", "(", "uint8_t", ")", "(", "(", "Imm", ">>", "(", "8", "*", "j", ")", ")", "&", "0xff", ")", ")", ";", "}", "break", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "8", "0xff", "4", "0", "AMDGPU::isSISrcOperand", "255", "0", "\"Must be immediate or expr\"", "0", "4", "8", "0xff" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos Call Graph Builder\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Call Graph Builder\"" ]

[]

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

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

[ "TPC" ]

[]

[ "<s>", "const", "char", "*", "mips_output_load_label", "(", "void", ")", "{", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "switch", "(", "mips_abi", ")", "{", "case", "ABI_N32", ":", "return", "\"%[lw\\t%@,%%got_page(%0)(%+)\\n\\taddiu\\t%@,%@,%%got_ofst(%0)\"", ";", "case", "ABI_64", ":", "return", "\"%[ld\\t%@,%%got_page(%0)(%+)\\n\\tdaddiu\\t%@,%@,%%got_ofst(%0)\"", ";", "default", ":", "if", "(", "ISA_HAS_LOAD_DELAY", ")", "return", "\"%[lw\\t%@,%%got(%0)(%+)%#\\n\\taddiu\\t%@,%@,%%lo(%0)\"", ";", "return", "\"%[lw\\t%@,%%got(%0)(%+)\\n\\taddiu\\t%@,%@,%%lo(%0)\"", ";", "}", "else", "{", "if", "(", "Pmode", "==", "DImode", ")", "return", "\"%[dla\\t%@,%0\"", ";", "else", "return", "\"%[la\\t%@,%0\"", ";", "}", "}", "</s>" ]

[ "Return", "an", "asm", "sequence", "to", "start", "a", "noat", "block", "and", "load", "the", "address", "of", "a", "label", "into", "$", "1", "." ]

[ "mips", "\"%[lw\\t%@,%%got_page(%0)(%+)\\n\\taddiu\\t%@,%@,%%got_ofst(%0)\"", "\"%[ld\\t%@,%%got_page(%0)(%+)\\n\\tdaddiu\\t%@,%@,%%got_ofst(%0)\"", "\"%[lw\\t%@,%%got(%0)(%+)%#\\n\\taddiu\\t%@,%@,%%lo(%0)\"", "\"%[lw\\t%@,%%got(%0)(%+)\\n\\taddiu\\t%@,%@,%%lo(%0)\"", "\"%[dla\\t%@,%0\"", "\"%[la\\t%@,%0\"" ]

[]

[ "<s>", "static", "rtx", "frame_emit_store", "(", "int", "regno", ",", "int", "regno_note", ",", "rtx", "addr", ",", "rtx", "cfa", ",", "int", "cfa_offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "addr", ")", ";", "rtx", "mov", "=", "gen_movdi", "(", "mem", ",", "reg", ")", ";", "rtx", "reg_note", "=", "gen_rtx_REG", "(", "DImode", ",", "regno_note", ")", ";", "rtx", "cfa_relative_addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "cfa", ",", "GEN_INT", "(", "cfa_offset", ")", ")", ";", "rtx", "cfa_relative_mem", "=", "gen_frame_mem", "(", "DImode", ",", "cfa_relative_addr", ")", ";", "rtx", "real", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "cfa_relative_mem", ",", "reg_note", ")", ";", "add_reg_note", "(", "mov", ",", "REG_CFA_OFFSET", ",", "real", ")", ";", "return", "emit_insn", "(", "mov", ")", ";", "}", "</s>" ]

[ "Emit", "a", "store", "in", "the", "stack", "frame", "to", "save", "REGNO", "at", "address", "ADDR", ",", "and", "emit", "the", "corresponding", "REG_CFA_OFFSET", "note", "described", "by", "CFA", "and", "CFA_OFFSET", ".", "Return", "the", "emitted", "insn", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "PPC", "::", "NOP", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::NOP" ]

[]

[ "<s>", "bool", "AMDGPUUseNativeCalls", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", "||", "UseNative", ".", "empty", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "!", "CI", ")", "continue", ";", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "Callee", "==", "0", ")", "continue", ";", "if", "(", "Simplifier", ".", "useNative", "(", "CI", ")", ")", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SIScheduleBlock", "::", "releaseSuccessors", "(", "SUnit", "*", "SU", ",", "bool", "InOrOutBlock", ")", "{", "for", "(", "SDep", "&", "Succ", ":", "SU", "->", "Succs", ")", "{", "SUnit", "*", "SuccSU", "=", "Succ", ".", "getSUnit", "(", ")", ";", "if", "(", "SuccSU", "->", "NodeNum", ">=", "DAG", "->", "SUnits", ".", "size", "(", ")", ")", "continue", ";", "if", "(", "BC", "->", "isSUInBlock", "(", "SuccSU", ",", "ID", ")", "!=", "InOrOutBlock", ")", "continue", ";", "releaseSucc", "(", "SU", ",", "&", "Succ", ")", ";", "if", "(", "SuccSU", "->", "NumPredsLeft", "==", "0", "&&", "InOrOutBlock", ")", "TopReadySUs", ".", "push_back", "(", "SuccSU", ")", ";", "}", "}", "</s>" ]

[ "releaseSuccessors", "-", "Call", "releaseSucc", "on", "each", "of", "SU", "'s", "successors", "." ]

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

[]

[ "<s>", "static", "rtx", "emit_memset", "(", "rtx", "destmem", ",", "rtx", "destptr", ",", "rtx", "promoted_val", ",", "HOST_WIDE_INT", "size_to_move", ")", "{", "rtx", "dst", "=", "destmem", ";", "enum", "insn_code", "code", ";", "machine_mode", "move_mode", ";", "int", "piece_size", ",", "i", ";", "move_mode", "=", "GET_MODE", "(", "promoted_val", ")", ";", "if", "(", "move_mode", "==", "VOIDmode", ")", "move_mode", "=", "QImode", ";", "if", "(", "size_to_move", "<", "GET_MODE_SIZE", "(", "move_mode", ")", ")", "{", "unsigned", "int", "move_bits", "=", "size_to_move", "*", "BITS_PER_UNIT", ";", "move_mode", "=", "int_mode_for_size", "(", "move_bits", ",", "0", ")", ".", "require", "(", ")", ";", "promoted_val", "=", "gen_lowpart", "(", "move_mode", ",", "promoted_val", ")", ";", "}", "piece_size", "=", "GET_MODE_SIZE", "(", "move_mode", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", "&&", "promoted_val", "!=", "NULL_RTX", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "0", ")", ";", "gcc_assert", "(", "size_to_move", "%", "piece_size", "==", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size_to_move", ";", "i", "+=", "piece_size", ")", "{", "if", "(", "piece_size", "<=", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "{", "emit_insn", "(", "gen_strset", "(", "destptr", ",", "dst", ",", "promoted_val", ")", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "piece_size", ")", ";", "continue", ";", "}", "emit_insn", "(", "GEN_FCN", "(", "code", ")", "(", "dst", ",", "promoted_val", ")", ")", ";", "emit_move_insn", "(", "destptr", ",", "plus_constant", "(", "Pmode", ",", "copy_rtx", "(", "destptr", ")", ",", "piece_size", ")", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "piece_size", ")", ";", "}", "return", "dst", ";", "}", "</s>" ]

[ "This", "function", "emits", "moves", "to", "fill", "SIZE_TO_MOVE", "bytes", "starting", "from", "DESTMEM", "with", "value", "PROMOTED_VAL", ".", "SRC", "is", "passed", "by", "pointer", "to", "be", "updated", "on", "return", ".", "Return", "value", "is", "updated", "DST", "." ]

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

[]

[ "<s>", "virtual", "unsigned", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "return", "50", ";", "}", "</s>" ]

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

[ "CellSPU", "50" ]

[]

[ "<s>", "int", "aarch64_movk_shift", "(", "const", "wide_int_ref", "&", "and_val", ",", "const", "wide_int_ref", "&", "ior_val", ")", "{", "unsigned", "int", "precision", "=", "and_val", ".", "get_precision", "(", ")", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "0xffff", ";", "for", "(", "unsigned", "int", "shift", "=", "0", ";", "shift", "<", "precision", ";", "shift", "+=", "16", ")", "{", "if", "(", "and_val", "==", "~", "mask", "&&", "(", "ior_val", "&", "mask", ")", "==", "ior_val", ")", "return", "shift", ";", "mask", "<<=", "16", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Test", "whether", ":", "X", "=", "(", "X", "&", "AND_VAL", ")", "|", "IOR_VAL", ";", "can", "be", "implemented", "using", ":", "MOVK", "X", ",", "#", "(", "IOR_VAL", ">", ">", "shift", ")", ",", "LSL", "#", "shift", "Return", "the", "shift", "if", "so", ",", "otherwise", "return", "-1", "." ]

[ "aarch64", "0xffff", "0", "16", "16", "1" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AArch64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Unexpected instruction for custom inserter!\"", ")", ";", "case", "AArch64", "::", "F128CSEL", ":", "return", "EmitF128CSEL", "(", "MI", ",", "BB", ")", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "emitPatchPoint", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Unexpected instruction for custom inserter!\"", "AArch64::F128CSEL" ]

[]

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

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

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

[]

[ "<s>", "DecodeStatus", "VEDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint64_t", "Insn", ";", "bool", "isLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "DecodeStatus", "Result", "=", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "isLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableVE64", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "8", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "8" ]

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "oi", "=", "i", "==", "2", "?", "1", ":", "2", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "spOffset", "=", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "-", "spOffset", ")", ":", "spOffset", ";", "spOffset", "+=", "MI", ".", "getOperand", "(", "oi", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "MI", ".", "getOperand", "(", "oi", ")", ".", "ChangeToImmediate", "(", "spOffset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_emit_i387_round", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "inmode", "=", "GET_MODE", "(", "op1", ")", ";", "machine_mode", "outmode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "e1", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "e2", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "rtx", "half", "=", "const_double_from_real_value", "(", "dconsthalf", ",", "XFmode", ")", ";", "rtx", "res", "=", "gen_reg_rtx", "(", "outmode", ")", ";", "rtx_code_label", "*", "jump_label", "=", "gen_label_rtx", "(", ")", ";", "rtx", "(", "*", "floor_insn", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "neg_insn", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx_insn", "*", "insn", ";", "rtx", "tmp", ";", "switch", "(", "inmode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "tmp", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_FLOAT_EXTEND", "(", "XFmode", ",", "op1", ")", ")", ")", ";", "op1", "=", "tmp", ";", "break", ";", "case", "E_XFmode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "outmode", ")", "{", "case", "E_SFmode", ":", "floor_insn", "=", "gen_frndintxf2_floor", ";", "neg_insn", "=", "gen_negsf2", ";", "break", ";", "case", "E_DFmode", ":", "floor_insn", "=", "gen_frndintxf2_floor", ";", "neg_insn", "=", "gen_negdf2", ";", "break", ";", "case", "E_XFmode", ":", "floor_insn", "=", "gen_frndintxf2_floor", ";", "neg_insn", "=", "gen_negxf2", ";", "break", ";", "case", "E_HImode", ":", "floor_insn", "=", "gen_lfloorxfhi2", ";", "neg_insn", "=", "gen_neghi2", ";", "break", ";", "case", "E_SImode", ":", "floor_insn", "=", "gen_lfloorxfsi2", ";", "neg_insn", "=", "gen_negsi2", ";", "break", ";", "case", "E_DImode", ":", "floor_insn", "=", "gen_lfloorxfdi2", ";", "neg_insn", "=", "gen_negdi2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_fxamxf2_i387", "(", "scratch", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_absxf2", "(", "e1", ",", "op1", ")", ")", ";", "half", "=", "force_reg", "(", "XFmode", ",", "half", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "e2", ",", "gen_rtx_PLUS", "(", "XFmode", ",", "e1", ",", "half", ")", ")", ")", ";", "switch", "(", "outmode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "{", "tmp", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "emit_insn", "(", "floor_insn", "(", "tmp", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "res", ",", "gen_rtx_UNSPEC", "(", "outmode", ",", "gen_rtvec", "(", "1", ",", "tmp", ")", ",", "UNSPEC_TRUNC_NOOP", ")", ")", ")", ";", "}", "break", ";", "default", ":", "emit_insn", "(", "floor_insn", "(", "res", ",", "e2", ")", ")", ";", "}", "emit_insn", "(", "gen_testqi_ext_1_ccno", "(", "scratch", ",", "GEN_INT", "(", "0x02", ")", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "jump_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "50", "/", "100", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "jump_label", ";", "emit_insn", "(", "neg_insn", "(", "res", ",", "res", ")", ")", ";", "emit_label", "(", "jump_label", ")", ";", "LABEL_NUSES", "(", "jump_label", ")", "=", "1", ";", "emit_move_insn", "(", "op0", ",", "res", ")", ";", "}", "</s>" ]

[ "Emit", "code", "for", "round", "calculation", "." ]

[ "i386", "1", "0x02", "50", "100", "1" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "Hexagon" ]

[]

[ "<s>", "RegisterBankInfo", "::", "InstructionMapping", "X86RegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opc", ")", ")", "{", "InstructionMapping", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "return", "getSameOperandsMapping", "(", "MI", ",", "false", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_FADD", ":", "case", "TargetOpcode", "::", "G_FSUB", ":", "case", "TargetOpcode", "::", "G_FMUL", ":", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "getSameOperandsMapping", "(", "MI", ",", "true", ")", ";", "break", ";", "default", ":", "break", ";", "}", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "SmallVector", "<", "PartialMappingIdx", ",", "4", ">", "OpRegBankIdx", "(", "NumOperands", ")", ";", "getInstrPartialMappingIdxs", "(", "MI", ",", "MRI", ",", "false", ",", "OpRegBankIdx", ")", ";", "SmallVector", "<", "const", "ValueMapping", "*", ",", "8", ">", "OpdsMapping", "(", "NumOperands", ")", ";", "if", "(", "!", "getInstrValueMapping", "(", "MI", ",", "OpRegBankIdx", ",", "OpdsMapping", ")", ")", "return", "InstructionMapping", "(", ")", ";", "return", "InstructionMapping", "{", "DefaultMappingID", ",", "1", ",", "getOperandsMapping", "(", "OpdsMapping", ")", ",", "NumOperands", "}", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "X86", "X86", "4", "8", "1" ]

[]

[ "<s>", "unsigned", "TOYRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TOY", "::", "SP", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::SP" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "MemoryObject", "const", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "std", "::", "array", "<", "uint8_t", ",", "4", ">", "Bytes", ";", "Size", "=", "4", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "Bytes", ".", "size", "(", ")", ",", "Bytes", ".", "data", "(", ")", ")", "==", "-", "1", ")", "{", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "insn", "=", "llvm", "::", "support", "::", "endian", "::", "read", "<", "uint32_t", ",", "llvm", "::", "support", "::", "little", ",", "llvm", "::", "support", "::", "unaligned", ">", "(", "Bytes", ".", "data", "(", ")", ")", ";", "insn", "&=", "~", "static_cast", "<", "uint32_t", ">", "(", "HexagonII", "::", "InstParseBits", "::", "INST_PARSE_MASK", ")", ";", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "4", "4", "1", "support::endian", "support::little", "support::unaligned", "HexagonII::InstParseBits" ]

[]

[ "<s>", "static", "rtx", "frv_expand_mrdacc_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "rtx", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "1", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "MRDACC", "and", "MRDACCG", ".", "These", "builtins", "take", "a", "single", "accumulator", "number", "or", "accumulator", "guard", "number", "as", "argument", "and", "return", "an", "SI", "integer", "." ]

[ "frv", "1" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "const", "IntrinsicData", "*", "IntrData", "=", "getIntrinsicWithChain", "(", "Intrinsic", ")", ";", "if", "(", "!", "IntrData", ")", "return", "false", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MONone", ";", "Info", ".", "offset", "=", "0", ";", "switch", "(", "IntrData", "->", "Type", ")", "{", "case", "TRUNCATE_TO_MEM_VI8", ":", "case", "TRUNCATE_TO_MEM_VI16", ":", "case", "TRUNCATE_TO_MEM_VI32", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "MVT", "VT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "MVT", "ScalarVT", "=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ";", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI8", ")", "ScalarVT", "=", "MVT", "::", "i8", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI16", ")", "ScalarVT", "=", "MVT", "::", "i16", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI32", ")", "ScalarVT", "=", "MVT", "::", "i32", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "ScalarVT", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "break", ";", "}", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::INTRINSIC_W_CHAIN", "0", "0", "MVT::getVT", "1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::getVectorVT", "1" ]

[]

[ "<s>", "bool", "sh2a_function_vector_p", "(", "tree", "func", ")", "{", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "for", "(", "tree", "list", "=", "SH_ATTRIBUTES", "(", "func", ")", ";", "list", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ")", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "FUNC", "has", "been", "assigned", "the", "attribute", "``", "function_vector", "''", "." ]

[ "sh", "\"function_vector\"" ]

[]

[ "<s>", "static", "void", "arm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk", ")", ")", ";", "assemble_start_function", "(", "thunk", ",", "fnname", ")", ";", "if", "(", "TARGET_32BIT", ")", "arm32_output_mi_thunk", "(", "file", ",", "thunk", ",", "delta", ",", "vcall_offset", ",", "function", ")", ";", "else", "arm_thumb1_mi_thunk", "(", "file", ",", "thunk", ",", "delta", ",", "vcall_offset", ",", "function", ")", ";", "assemble_end_function", "(", "thunk", ",", "fnname", ")", ";", "}", "</s>" ]

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

[ "arm" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "{", "if", "(", "!", "Resolved", "&&", "!", "WasForced", ")", "return", "true", ";", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "RISCV", "::", "fixup_riscv_rvc_branch", ":", "return", "Offset", ">", "254", "||", "Offset", "<", "-", "256", ";", "case", "RISCV", "::", "fixup_riscv_rvc_jump", ":", "return", "Offset", ">", "2046", "||", "Offset", "<", "-", "2048", ";", "}", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "RI5CY", "RISCV", "RISCV::fixup_riscv_rvc_branch", "254", "256", "RISCV::fixup_riscv_rvc_jump", "2046", "2048" ]

[]

[ "<s>", "static", "void", "save_restore_insns", "(", "int", "prologue", ")", "{", "rtx", "base_reg_rtx", ",", "reg_rtx", ",", "mem_rtx", ",", "isr_reg_rtx", "=", "0", ",", "isr_mem_rtx", "=", "0", ";", "rtx", "isr_msr_rtx", "=", "0", ",", "insn", ";", "long", "mask", "=", "current_frame_info", ".", "mask", ";", "HOST_WIDE_INT", "gp_offset", ";", "int", "regno", ";", "if", "(", "frame_pointer_needed", "&&", "!", "BITSET_P", "(", "mask", ",", "HARD_FRAME_POINTER_REGNUM", "-", "GP_REG_FIRST", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "mask", "==", "0", ")", "return", ";", "gp_offset", "=", "current_frame_info", ".", "gp_offset", ";", "gcc_assert", "(", "gp_offset", ">", "0", ")", ";", "base_reg_rtx", "=", "stack_pointer_rtx", ";", "if", "(", "microblaze_is_interrupt_variant", "(", ")", ")", "{", "isr_mem_rtx", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "base_reg_rtx", ",", "GEN_INT", "(", "current_frame_info", ".", "gp_offset", "-", "UNITS_PER_WORD", ")", ")", ")", ";", "MEM_VOLATILE_P", "(", "isr_mem_rtx", ")", "=", "1", ";", "isr_reg_rtx", "=", "gen_rtx_REG", "(", "SImode", ",", "MB_ABI_MSR_SAVE_REG", ")", ";", "isr_msr_rtx", "=", "gen_rtx_REG", "(", "SImode", ",", "ST_REG", ")", ";", "}", "if", "(", "microblaze_is_interrupt_variant", "(", ")", "&&", "!", "prologue", ")", "{", "emit_move_insn", "(", "isr_reg_rtx", ",", "isr_mem_rtx", ")", ";", "emit_move_insn", "(", "isr_msr_rtx", ",", "isr_reg_rtx", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "SImode", ",", "isr_reg_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "SImode", ",", "isr_msr_rtx", ")", ")", ";", "}", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "{", "if", "(", "BITSET_P", "(", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "if", "(", "regno", "==", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "continue", ";", "reg_rtx", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "insn", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base_reg_rtx", ",", "GEN_INT", "(", "gp_offset", ")", ")", ";", "mem_rtx", "=", "gen_rtx_MEM", "(", "SImode", ",", "insn", ")", ";", "if", "(", "microblaze_is_interrupt_variant", "(", ")", "||", "save_volatiles", ")", "MEM_VOLATILE_P", "(", "mem_rtx", ")", "=", "1", ";", "if", "(", "prologue", ")", "{", "insn", "=", "emit_move_insn", "(", "mem_rtx", ",", "reg_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "insn", "=", "emit_move_insn", "(", "reg_rtx", ",", "mem_rtx", ")", ";", "}", "gp_offset", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "}", "}", "if", "(", "microblaze_is_interrupt_variant", "(", ")", "&&", "prologue", ")", "{", "emit_move_insn", "(", "isr_reg_rtx", ",", "isr_msr_rtx", ")", ";", "emit_move_insn", "(", "isr_mem_rtx", ",", "isr_reg_rtx", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "SImode", ",", "isr_reg_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "SImode", ",", "isr_msr_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Save", "or", "restore", "instructions", "based", "on", "whether", "this", "is", "the", "prologue", "or", "epilogue", ".", "prologue", "is", "1", "for", "the", "prologue", "." ]

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

[]

[ "<s>", "unsigned", "RISCVAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "RISCVOperand", "&", "Op", "=", "static_cast", "<", "RISCVOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "bool", "IsRegFPR64", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR64RegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "bool", "IsRegFPR64C", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR64CRegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "if", "(", "(", "IsRegFPR64", "&&", "Kind", "==", "MCK_FPR32", ")", "||", "(", "IsRegFPR64C", "&&", "Kind", "==", "MCK_FPR32C", ")", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR64ToFPR32", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "if", "(", "IsRegFPR64", "&&", "Kind", "==", "MCK_FPR16", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR64ToFPR16", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "RI5CY", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::FPR64RegClassID", "RISCV", "RISCV::FPR64CRegClassID" ]

[]

[ "<s>", "void", "rs6000_call_aix", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "flag", ",", "rtx", "cookie", ")", "{", "const", "bool", "direct_call_p", "=", "GET_CODE", "(", "func_desc", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "func_desc", ")", ";", "rtx", "toc_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGNUM", ")", ";", "rtx", "toc_load", "=", "NULL_RTX", ";", "rtx", "toc_restore", "=", "NULL_RTX", ";", "rtx", "func_addr", ";", "rtx", "abi_reg", "=", "NULL_RTX", ";", "rtx", "call", "[", "4", "]", ";", "int", "n_call", ";", "rtx", "insn", ";", "if", "(", "INTVAL", "(", "cookie", ")", "&", "CALL_LONG", ")", "func_desc", "=", "rs6000_longcall_ref", "(", "func_desc", ")", ";", "if", "(", "GET_CODE", "(", "func_desc", ")", "!=", "SYMBOL_REF", "||", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "func_desc", ")", ")", ")", "{", "rtx", "stack_ptr", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "stack_toc_offset", "=", "GEN_INT", "(", "RS6000_TOC_SAVE_SLOT", ")", ";", "rtx", "stack_toc_mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_ptr", ",", "stack_toc_offset", ")", ")", ";", "rtx", "stack_toc_unspec", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "stack_toc_offset", ")", ",", "UNSPEC_TOCSLOT", ")", ";", "toc_restore", "=", "gen_rtx_SET", "(", "toc_reg", ",", "stack_toc_unspec", ")", ";", "if", "(", "TARGET_SAVE_TOC_INDIRECT", "&&", "!", "cfun", "->", "calls_alloca", ")", "cfun", "->", "machine", "->", "save_toc_in_prologue", "=", "true", ";", "else", "{", "MEM_VOLATILE_P", "(", "stack_toc_mem", ")", "=", "1", ";", "emit_move_insn", "(", "stack_toc_mem", ",", "toc_reg", ")", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "func_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "emit_move_insn", "(", "func_addr", ",", "func_desc", ")", ";", "abi_reg", "=", "func_addr", ";", "}", "else", "{", "func_desc", "=", "force_reg", "(", "Pmode", ",", "func_desc", ")", ";", "func_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "func_addr", ",", "gen_rtx_MEM", "(", "Pmode", ",", "func_desc", ")", ")", ";", "rtx", "func_toc_offset", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ";", "rtx", "func_toc_mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "func_desc", ",", "func_toc_offset", ")", ")", ";", "toc_load", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "func_toc_mem", ")", ";", "if", "(", "!", "direct_call_p", "&&", "TARGET_POINTERS_TO_NESTED_FUNCTIONS", "&&", "!", "chain_already_loaded", "(", "get_current_sequence", "(", ")", "->", "next", "->", "last", ")", ")", "{", "rtx", "sc_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ";", "rtx", "func_sc_offset", "=", "GEN_INT", "(", "2", "*", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ";", "rtx", "func_sc_mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "func_desc", ",", "func_sc_offset", ")", ")", ";", "emit_move_insn", "(", "sc_reg", ",", "func_sc_mem", ")", ";", "abi_reg", "=", "sc_reg", ";", "}", "}", "}", "else", "{", "abi_reg", "=", "toc_reg", ";", "func_addr", "=", "func_desc", ";", "}", "call", "[", "0", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_addr", ")", ",", "flag", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "0", "]", "=", "gen_rtx_SET", "(", "value", ",", "call", "[", "0", "]", ")", ";", "n_call", "=", "1", ";", "if", "(", "toc_load", ")", "call", "[", "n_call", "++", "]", "=", "toc_load", ";", "if", "(", "toc_restore", ")", "call", "[", "n_call", "++", "]", "=", "toc_restore", ";", "call", "[", "n_call", "++", "]", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "n_call", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "if", "(", "abi_reg", ")", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "abi_reg", ")", ";", "}", "</s>" ]

[ "Expand", "code", "to", "perform", "a", "call", "under", "the", "AIX", "or", "ELFv2", "ABI", "." ]

[ "powerpcspe", "4", "1", "1", "12", "2", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "{", "if", "(", "Amount", "<", "0", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SaveDecSpF16", ")", ")", ".", "addImm", "(", "-", "Amount", ")", ";", "else", "if", "(", "Amount", ">", "0", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "RestoreIncSpF16", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "assert", "(", "false", "&&", "\"adjust stack pointer amount exceeded\"", ")", ";", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "16", "0", "Mips::SaveDecSpF16", "0", "Mips::RestoreIncSpF16", "\"adjust stack pointer amount exceeded\"" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitHeader", "(", "Module", "&", "M", ",", "raw_ostream", "&", "O", ",", "const", "NVPTXSubtarget", "&", "STI", ")", "{", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"// Generated by LLVM NVPTX Back-End\\n\"", ";", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"\\n\"", ";", "unsigned", "PTXVersion", "=", "STI", ".", "getPTXVersion", "(", ")", ";", "O", "<<", "\".version \"", "<<", "(", "PTXVersion", "/", "10", ")", "<<", "\".\"", "<<", "(", "PTXVersion", "%", "10", ")", "<<", "\"\\n\"", ";", "O", "<<", "\".target \"", ";", "O", "<<", "STI", ".", "getTargetName", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "if", "(", "NTM", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "NVCL", ")", "O", "<<", "\", texmode_independent\"", ";", "if", "(", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ")", "O", "<<", "\"//, debug\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\".address_size \"", ";", "if", "(", "NTM", ".", "is64Bit", "(", ")", ")", "O", "<<", "\"64\"", ";", "else", "O", "<<", "\"32\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Emit", "the", "header", "for", "this", "unit", ",", "not", "including", "the", "initial", "length", "field", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "\"//\\n\"", "\"// Generated by LLVM NVPTX Back-End\\n\"", "\"//\\n\"", "\"\\n\"", "\".version \"", "10", "\".\"", "10", "\"\\n\"", "\".target \"", "NVPTX", "NVPTX", "NVPTX::NVCL", "\", texmode_independent\"", "\"//, debug\"", "\"\\n\"", "\".address_size \"", "\"64\"", "\"32\"", "\"\\n\"", "\"\\n\"" ]

[]

[ "<s>", "void", "TOYMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "getSize", "(", ")", "!=", "4", ")", "{", "llvm_unreachable", "(", "\"Unexpected instruction size!\"", ")", ";", "}", "const", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "EmitConstant", "(", "Binary", ",", "Desc", ".", "getSize", "(", ")", ",", "OS", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "4", "\"Unexpected instruction size!\"" ]

[]

[ "<s>", "void", "MetadataStreamerV3", "::", "begin", "(", "const", "Module", "&", "Mod", ")", "{", "emitVersion", "(", ")", ";", "emitPrintf", "(", "Mod", ")", ";", "getRootMetadata", "(", "\"amdhsa.kernels\"", ")", "=", "HSAMetadataDoc", "->", "getArrayNode", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "AMDGPU", "\"amdhsa.kernels\"" ]

[]

[ "<s>", "const", "char", "*", "ARMTargetLowering", "::", "LowerXConstraint", "(", "EVT", "ConstraintVT", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasVFP2", "(", ")", ")", "return", "\"r\"", ";", "if", "(", "ConstraintVT", ".", "isFloatingPoint", "(", ")", ")", "return", "\"w\"", ";", "if", "(", "ConstraintVT", ".", "isVector", "(", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "ConstraintVT", ".", "getSizeInBits", "(", ")", "==", "64", "||", "ConstraintVT", ".", "getSizeInBits", "(", ")", "==", "128", ")", ")", "return", "\"w\"", ";", "return", "\"r\"", ";", "}", "</s>" ]

[ "Try", "to", "replace", "an", "X", "constraint", ",", "which", "matches", "anything", ",", "with", "another", "that", "has", "more", "specific", "requirements", "based", "on", "the", "type", "of", "the", "corresponding", "operand", "." ]

[ "ARM", "ARM", "\"r\"", "\"w\"", "64", "128", "\"w\"", "\"r\"" ]

[]

[ "<s>", "rtx", "ia64_function_value", "(", "tree", "valtype", ",", "tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", ";", "enum", "machine_mode", "hfa_mode", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "hfa_mode", "=", "hfa_element_mode", "(", "valtype", ",", "0", ")", ";", "if", "(", "hfa_mode", "!=", "VOIDmode", ")", "{", "rtx", "loc", "[", "8", "]", ";", "int", "i", ";", "int", "hfa_size", ";", "int", "byte_size", ";", "int", "offset", ";", "hfa_size", "=", "GET_MODE_SIZE", "(", "hfa_mode", ")", ";", "byte_size", "=", "(", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "valtype", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "offset", "=", "0", ";", "for", "(", "i", "=", "0", ";", "offset", "<", "byte_size", ";", "i", "++", ")", "{", "loc", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "hfa_mode", ",", "FR_ARG_FIRST", "+", "i", ")", ",", "GEN_INT", "(", "offset", ")", ")", ";", "offset", "+=", "hfa_size", ";", "}", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "i", ",", "loc", ")", ")", ";", "}", "else", "if", "(", "FLOAT_TYPE_P", "(", "valtype", ")", "&&", "mode", "!=", "TFmode", "&&", "mode", "!=", "TCmode", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FR_ARG_FIRST", ")", ";", "else", "{", "bool", "need_parallel", "=", "false", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "(", "mode", "==", "BLKmode", "||", "(", "valtype", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", ")", ")", ")", "need_parallel", "=", "true", ";", "else", "if", "(", "mode", "==", "XFmode", "||", "mode", "==", "XCmode", "||", "mode", "==", "RFmode", ")", "need_parallel", "=", "true", ";", "if", "(", "need_parallel", ")", "{", "rtx", "loc", "[", "8", "]", ";", "int", "offset", ";", "int", "bytesize", ";", "int", "i", ";", "offset", "=", "0", ";", "bytesize", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "bytesize", "==", "0", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GR_RET_FIRST", ")", ";", "for", "(", "i", "=", "0", ";", "offset", "<", "bytesize", ";", "i", "++", ")", "{", "loc", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "DImode", ",", "GR_RET_FIRST", "+", "i", ")", ",", "GEN_INT", "(", "offset", ")", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "i", ",", "loc", ")", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "GR_RET_FIRST", ")", ";", "}", "}", "</s>" ]

[ "Return", "rtx", "for", "register", "that", "holds", "the", "function", "return", "value", "." ]

[ "ia64", "0", "8", "0", "0", "8", "0", "0", "0" ]

[]

[ "<s>", "static", "tree", "msp430_attr", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "if", "(", "args", "!=", "NULL", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "switch", "(", "TREE_CODE", "(", "value", ")", ")", "{", "case", "STRING_CST", ":", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"reset\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"nmi\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"watchdog\"", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"unrecognized interrupt vector argument of %qE attribute\"", ",", "name", ")", ";", "break", ";", "case", "INTEGER_CST", ":", "if", "(", "wi", "::", "gtu_p", "(", "wi", "::", "to_wide", "(", "value", ")", ",", "63", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"numeric argument of %qE attribute must be in range [0-63]\"", ",", "name", ")", ";", "break", ";", "default", ":", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant \"", "\"or number\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "break", ";", "}", "}", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "message", "=", "\"%qE attribute only applies to functions\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "&&", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "message", "=", "\"interrupt handlers must be void\"", ";", "else", "{", "TREE_USED", "(", "*", "node", ")", "=", "1", ";", "DECL_PRESERVE_P", "(", "*", "node", ")", "=", "1", ";", "}", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"critical attribute has no effect on interrupt functions\"", ")", ";", "DECL_ATTRIBUTES", "(", "*", "node", ")", "=", "remove_attribute", "(", "ATTR_CRIT", ",", "DECL_ATTRIBUTES", "(", "*", "node", ")", ")", ";", "}", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_CRIT", ")", ")", "{", "if", "(", "is_interrupt_func", "(", "*", "node", ")", ")", "message", "=", "\"critical attribute has no effect on interrupt functions\"", ";", "}", "if", "(", "message", ")", "{", "warning", "(", "OPT_Wattributes", ",", "message", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Verify", "MSP430", "specific", "attributes", "." ]

[ "msp430", "\"reset\"", "\"nmi\"", "\"watchdog\"", "\"unrecognized interrupt vector argument of %qE attribute\"", "63", "\"numeric argument of %qE attribute must be in range [0-63]\"", "\"argument of %qE attribute is not a string constant \"", "\"or number\"", "\"%qE attribute only applies to functions\"", "\"interrupt handlers must be void\"", "1", "1", "\"critical attribute has no effect on interrupt functions\"", "\"critical attribute has no effect on interrupt functions\"" ]

[]

[ "<s>", "inline", "GCNRegPressure", "max", "(", "const", "GCNRegPressure", "&", "P1", ",", "const", "GCNRegPressure", "&", "P2", ")", "{", "GCNRegPressure", "Res", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "GCNRegPressure", "::", "TOTAL_KINDS", ";", "++", "I", ")", "Res", ".", "Value", "[", "I", "]", "=", "std", "::", "max", "(", "P1", ".", "Value", "[", "I", "]", ",", "P2", ".", "Value", "[", "I", "]", ")", ";", "return", "Res", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "possible", "frequency", ",", "the", "saturation", "value", "." ]

[ "AMDGPU", "0" ]

[]