Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "IsVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "IsVolatile", ")", "return", "SDValue", "(", ")", ";", "if", "(", "ConstantSDNode", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitMemMem", "(", "DAG", ",", "DL", ",", "SystemZISD", "::", "MVC", ",", "SystemZISD", "::", "MVC_LOOP", ",", "Chain", ",", "Dst", ",", "Src", ",", "CSize", "->", "getZExtValue", "(", ")", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZISD::MVC", "SystemZISD::MVC_LOOP" ]

[]

[ "<s>", "MachineInstrBuilder", "SIInstrInfo", "::", "getAddNoCarry", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ")", "const", "{", "if", "(", "ST", ".", "hasAddNoCarry", "(", ")", ")", "return", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_U32_e64", ")", ",", "DestReg", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "UnusedCarry", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MRI", ".", "setRegAllocationHint", "(", "UnusedCarry", ",", "0", ",", "AMDGPU", "::", "VCC", ")", ";", "return", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "DestReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ";", "}", "</s>" ]

[ "Return", "a", "partially", "built", "integer", "add", "instruction", "without", "carry", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_ADD_U32_e64", "AMDGPU::SReg_64RegClass", "0", "AMDGPU::VCC", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "static", "bool", "visium_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "argument", "must", "be", "passed", "by", "indirect", "reference", "." ]

[ "visium" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "NumOps", "=", "Inst", ".", "getNumOperands", "(", ")", ";", "if", "(", "NumOps", "==", "0", ")", "return", "false", ";", "switch", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "NumOps", "-", "1", "]", ".", "OperandType", ")", "{", "case", "MCOI", "::", "OPERAND_UNKNOWN", ":", "case", "MCOI", "::", "OPERAND_IMMEDIATE", ":", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "NumOps", "-", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "Nyuzi", "0", "1", "1" ]

[]

[ "<s>", "int", "class_max_nregs", "(", "enum", "reg_class", "class", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "A", "C", "expression", "for", "the", "maximum", "number", "of", "consecutive", "registers", "of", "class", "CLASS", "needed", "to", "hold", "a", "value", "of", "mode", "MODE", "." ]

[ "avr", "1" ]

[]

[ "<s>", "static", "void", "register_vector_type", "(", "vector_type_index", "type", ")", "{", "tree", "vectype", "=", "abi_vector_types", "[", "type", "]", ";", "if", "(", "!", "vectype", ")", "return", ";", "tree", "id", "=", "get_identifier", "(", "vector_types", "[", "type", "]", ".", "name", ")", ";", "tree", "decl", "=", "build_decl", "(", "input_location", ",", "TYPE_DECL", ",", "id", ",", "vectype", ")", ";", "decl", "=", "lang_hooks", ".", "decls", ".", "pushdecl", "(", "decl", ")", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "TYPE_DECL", "&&", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "&&", "TYPE_MAIN_VARIANT", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "vectype", ")", "vectype", "=", "TREE_TYPE", "(", "decl", ")", ";", "builtin_types", "[", "type", "]", ".", "vector", "=", "vectype", ";", "builtin_types", "[", "type", "]", ".", "vector_ptr", "=", "build_pointer_type", "(", "vectype", ")", ";", "}", "</s>" ]

[ "Register", "vector", "type", "TYPE", "under", "its", "risv_vector.h", "name", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "inlineStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologMBB", ")", "const", "{", "const", "StringRef", "ChkStkStubSymbol", "=", "\"__chkstk_stub\"", ";", "MachineInstr", "*", "ChkStkStub", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "PrologMBB", ")", "{", "if", "(", "MI", ".", "isCall", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isSymbol", "(", ")", "&&", "ChkStkStubSymbol", "==", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ")", "{", "ChkStkStub", "=", "&", "MI", ";", "break", ";", "}", "}", "if", "(", "ChkStkStub", "!=", "nullptr", ")", "{", "assert", "(", "!", "ChkStkStub", "->", "isBundled", "(", ")", "&&", "\"Not expecting bundled instructions here\"", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "next", "(", "ChkStkStub", "->", "getIterator", "(", ")", ")", ";", "assert", "(", "std", "::", "prev", "(", "MBBI", ")", "==", "ChkStkStub", "&&", "\"MBBI expected after __chkstk_stub.\"", ")", ";", "DebugLoc", "DL", "=", "PrologMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "emitStackProbeInline", "(", "MF", ",", "PrologMBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "ChkStkStub", "->", "eraseFromParent", "(", ")", ";", "}", "}", "</s>" ]

[ "Replace", "a", "StackProbe", "inline-stub", "with", "the", "actual", "probe", "code", "inline", "." ]

[ "X86", "X86", "\"__chkstk_stub\"", "0", "0", "\"Not expecting bundled instructions here\"", "\"MBBI expected after __chkstk_stub.\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "return", "CSR_NaCl_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "return", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "rtx", "c6x_subword", "(", "rtx", "op", ",", "bool", "high_p", ")", "{", "unsigned", "int", "byte", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "DImode", ";", "if", "(", "TARGET_BIG_ENDIAN", "?", "!", "high_p", ":", "high_p", ")", "byte", "=", "UNITS_PER_WORD", ";", "else", "byte", "=", "0", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "REG_P", "(", "addr", ")", ")", "return", "adjust_address", "(", "op", ",", "word_mode", ",", "byte", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "return", "simplify_gen_subreg", "(", "word_mode", ",", "op", ",", "mode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Return", "one", "word", "of", "double-word", "value", "OP", ".", "HIGH_P", "is", "true", "to", "select", "the", "high", "part", ",", "false", "to", "select", "the", "low", "part", ".", "When", "encountering", "auto-increment", "addressing", ",", "we", "make", "the", "assumption", "that", "the", "low", "part", "is", "going", "to", "be", "accessed", "first", "." ]

[ "c6x", "0", "0" ]

[]

[ "<s>", "static", "void", "ix86_set_indirect_branch_type", "(", "tree", "fndecl", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_unset", ")", "{", "tree", "attr", "=", "lookup_attribute", "(", "\"indirect_branch\"", ",", "DECL_ATTRIBUTES", "(", "fndecl", ")", ")", ";", "if", "(", "attr", "!=", "NULL", ")", "{", "tree", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "gcc_unreachable", "(", ")", ";", "tree", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"keep\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_keep", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_thunk", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-inline\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_thunk_inline", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-extern\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "indirect_branch_thunk_extern", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "cfun", "->", "machine", "->", "indirect_branch_type", "=", "ix86_indirect_branch", ";", "if", "(", "(", "ix86_cmodel", "==", "CM_LARGE", "||", "ix86_cmodel", "==", "CM_LARGE_PIC", ")", "&&", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "||", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", ")", ")", "error", "(", "\"%<-mindirect-branch=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", ",", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "?", "\"thunk-extern\"", ":", "\"thunk\"", ")", ")", ";", "if", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "&&", "flag_check_pointer_bounds", "&&", "(", "flag_cf_protection", "&", "CF_BRANCH", ")", "!=", "0", ")", "error", "(", "\"%<-mindirect-branch=thunk-extern%>, \"", "\"%<-fcf-protection=branch%> and \"", "\"%<-fcheck-pointer-bounds%> are not compatible\"", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_unset", ")", "{", "tree", "attr", "=", "lookup_attribute", "(", "\"function_return\"", ",", "DECL_ATTRIBUTES", "(", "fndecl", ")", ")", ";", "if", "(", "attr", "!=", "NULL", ")", "{", "tree", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "gcc_unreachable", "(", ")", ";", "tree", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"keep\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_keep", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_thunk", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-inline\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_thunk_inline", ";", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"thunk-extern\"", ")", "==", "0", ")", "cfun", "->", "machine", "->", "function_return_type", "=", "indirect_branch_thunk_extern", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "cfun", "->", "machine", "->", "function_return_type", "=", "ix86_function_return", ";", "if", "(", "(", "ix86_cmodel", "==", "CM_LARGE", "||", "ix86_cmodel", "==", "CM_LARGE_PIC", ")", "&&", "(", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk_extern", ")", "||", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk", ")", ")", ")", "error", "(", "\"%<-mfunction-return=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", ",", "(", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk_extern", ")", "?", "\"thunk-extern\"", ":", "\"thunk\"", ")", ")", ";", "}", "}", "</s>" ]

[ "Set", "the", "indirect_branch_type", "field", "from", "the", "function", "FNDECL", "." ]

[ "i386", "\"indirect_branch\"", "\"keep\"", "0", "\"thunk\"", "0", "\"thunk-inline\"", "0", "\"thunk-extern\"", "0", "\"%<-mindirect-branch=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", "\"thunk-extern\"", "\"thunk\"", "0", "\"%<-mindirect-branch=thunk-extern%>, \"", "\"%<-fcf-protection=branch%> and \"", "\"%<-fcheck-pointer-bounds%> are not compatible\"", "\"function_return\"", "\"keep\"", "0", "\"thunk\"", "0", "\"thunk-inline\"", "0", "\"thunk-extern\"", "0", "\"%<-mfunction-return=%s%> and %<-mcmodel=large%> are not \"", "\"compatible\"", "\"thunk-extern\"", "\"thunk\"" ]

[]

[ "<s>", "bool", "HexagonMCChecker", "::", "check", "(", "bool", "FullCheck", ")", "{", "bool", "chkP", "=", "checkPredicates", "(", ")", ";", "bool", "chkNV", "=", "checkNewValues", "(", ")", ";", "bool", "chkR", "=", "checkRegisters", "(", ")", ";", "bool", "chkRRO", "=", "checkRegistersReadOnly", "(", ")", ";", "checkRegisterCurDefs", "(", ")", ";", "bool", "chkS", "=", "checkSolo", "(", ")", ";", "bool", "chkSh", "=", "true", ";", "if", "(", "FullCheck", ")", "chkSh", "=", "checkShuffle", "(", ")", ";", "bool", "chkSl", "=", "true", ";", "if", "(", "FullCheck", ")", "chkSl", "=", "checkSlots", "(", ")", ";", "bool", "chkAXOK", "=", "checkAXOK", "(", ")", ";", "bool", "chkCofMax1", "=", "checkCOFMax1", "(", ")", ";", "bool", "chkHWLoop", "=", "checkHWLoop", "(", ")", ";", "bool", "chkValidTmpDst", "=", "FullCheck", "?", "checkValidTmpDst", "(", ")", ":", "true", ";", "bool", "chkLegalVecRegPair", "=", "checkLegalVecRegPair", "(", ")", ";", "bool", "ChkHVXAccum", "=", "checkHVXAccum", "(", ")", ";", "bool", "chk", "=", "chkP", "&&", "chkNV", "&&", "chkR", "&&", "chkRRO", "&&", "chkS", "&&", "chkSh", "&&", "chkSl", "&&", "chkAXOK", "&&", "chkCofMax1", "&&", "chkHWLoop", "&&", "chkValidTmpDst", "&&", "chkLegalVecRegPair", "&&", "ChkHVXAccum", ";", "return", "chk", ";", "}", "</s>" ]

[ "Check", "if", "the", "constraints", "are", "satisfiable", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getPICCallReg", "(", ")", "{", "return", "Mips", "::", "T9", ";", "}", "</s>" ]

[ "Get", "PIC", "indirect", "call", "register", "." ]

[ "Mips", "Mips", "Mips::T9" ]

[]

[ "<s>", "void", "M680x0AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "M680x0", "M680x0", "256", "\"\\n\"", "\"unexpected instruction to relax: \"" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "UseTCCInDIV", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "void", "sh_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", ",", "signed", "int", "n_named_args", ",", "machine_mode", "mode", ")", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "=", "0", ";", "pcum", "->", "free_single_fp_reg", "=", "0", ";", "pcum", "->", "stack_regs", "=", "0", ";", "pcum", "->", "byref_regs", "=", "0", ";", "pcum", "->", "byref", "=", "0", ";", "pcum", "->", "outgoing", "=", "(", "n_named_args", "==", "-", "1", ")", "?", "0", ":", "1", ";", "pcum", "->", "renesas_abi", "=", "sh_attr_renesas_p", "(", "fntype", ")", "?", "1", ":", "0", ";", "if", "(", "fntype", ")", "{", "pcum", "->", "force_mem", "=", "(", "(", "TARGET_HITACHI", "||", "pcum", "->", "renesas_abi", ")", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ")", ";", "pcum", "->", "prototype_p", "=", "prototype_p", "(", "fntype", ")", ";", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "TARGET_SH5", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ";", "pcum", "->", "call_cookie", "=", "CALL_COOKIE_RET_TRAMP", "(", "TARGET_SHCOMPACT", "&&", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "==", "0", "&&", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", "==", "BLKmode", "?", "int_size_in_bytes", "(", "TREE_TYPE", "(", "fntype", ")", ")", ":", "GET_MODE_SIZE", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", ")", ">", "4", "&&", "(", "BASE_RETURN_VALUE_REG", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", "==", "FIRST_RET_REG", ")", ")", ";", "}", "else", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "0", ";", "pcum", "->", "prototype_p", "=", "FALSE", ";", "if", "(", "mode", "!=", "VOIDmode", ")", "{", "pcum", "->", "call_cookie", "=", "CALL_COOKIE_RET_TRAMP", "(", "TARGET_SHCOMPACT", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "BASE_RETURN_VALUE_REG", "(", "mode", ")", "==", "FIRST_RET_REG", ")", ";", "pcum", "->", "force_mem", "=", "(", "TARGET_DEFAULT", "&", "MASK_HITACHI", ")", "&&", "(", "mode", "==", "BLKmode", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "!", "(", "mode", "==", "DFmode", "&&", "TARGET_FPU_DOUBLE", ")", ")", ")", ";", "}", "else", "{", "pcum", "->", "call_cookie", "=", "0", ";", "pcum", "->", "force_mem", "=", "FALSE", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "CUMULATIVE_ARGS", "structure", "." ]

[ "sh", "0", "0", "0", "0", "0", "1", "0", "1", "1", "0", "0", "4", "0", "4", "4", "0" ]

[]

[ "<s>", "static", "hsa_status_t", "get_gpu_agent", "(", "hsa_agent_t", "agent", ",", "void", "*", "data", "__attribute__", "(", "(", "unused", ")", ")", ")", "{", "hsa_device_type_t", "device_type", ";", "XHSA", "(", "hsa_fns", ".", "hsa_agent_get_info_fn", "(", "agent", ",", "HSA_AGENT_INFO_DEVICE", ",", "&", "device_type", ")", ",", "\"Get agent type\"", ")", ";", "if", "(", "HSA_DEVICE_TYPE_GPU", "==", "device_type", ")", "{", "device", "=", "agent", ";", "return", "HSA_STATUS_INFO_BREAK", ";", "}", "return", "HSA_STATUS_SUCCESS", ";", "}", "</s>" ]

[ "Callback", "of", "hsa_iterate_agents", ".", "Called", "once", "for", "each", "available", "device", ",", "and", "returns", "``", "break", "''", "when", "a", "suitable", "one", "has", "been", "found", "." ]

[ "gcn", "\"Get agent type\"" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "Ins", ".", "size", "(", ")", ">=", "2", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"only small returns supported\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "InVals", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "Ins", "[", "i", "]", ".", "VT", ")", ")", ";", "return", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "1", ",", "Ins", "[", "0", "]", ".", "VT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "}", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_BPF64", ")", ";", "for", "(", "auto", "&", "Val", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Val", ".", "getLocReg", "(", ")", ",", "Val", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::InputArg", "16", "2", "\"only small returns supported\"", "0", "0", "1", "0", "1", "BPF", "1", "2", "0" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "addPass", "(", "createAArch64ExpandHardenedPseudosPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SystemZRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "SystemZMFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "SystemZ", "::", "RET", ":", "break", ";", "default", ":", "assert", "(", "0", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", "-", "SystemZMFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "--", "MBBI", ";", "if", "(", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "}", "if", "(", "StackSize", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64rmm", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64rm", ")", "&&", "\"Expected to see callee-save register restore code\"", ")", ";", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "SystemZ", "::", "R15D", ")", "&&", "\"Invalid stack frame calculation!\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isImm", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Unexpected restore code!\"", ")", ";", "}", "uint64_t", "Offset", "=", "NumBytes", "+", "MI", ".", "getOperand", "(", "i", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", ">", "524287", ")", "{", "NumBytes", "=", "Offset", "-", "524287", ";", "Offset", "=", "524287", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "NumBytes", ",", "TII", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::RET", "0", "\"Can only insert epilog into returning blocks\"", "SystemZ", "SystemZ::MOV64rmm", "SystemZ::MOV64rm", "\"Expected to see callee-save register restore code\"", "SystemZ::R15D", "\"Invalid stack frame calculation!\"", "0", "\"Unexpected restore code!\"", "524287", "524287", "524287" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARM64RegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "ARM64", "::", "CCRRegClass", ")", "return", "nullptr", ";", "return", "RC", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "ARM64", "ARM64", "ARM64::CCRRegClass" ]

[]

[ "<s>", "const", "CallLowering", "*", "getCallLowering", "(", ")", "const", "override", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "SPIRV" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "GV", ")", "{", "if", "(", "Optional", "<", "ConstantRange", ">", "CR", "=", "GV", "->", "getAbsoluteSymbolRange", "(", ")", ")", "{", "if", "(", "CR", "->", "getUnsignedMax", "(", ")", ".", "ult", "(", "128", ")", ")", "return", "X86II", "::", "MO_ABS8", ";", "else", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "}", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "if", "(", "!", "GV", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "return", "X86II", "::", "MO_COFFSTUB", ";", "}", "if", "(", "isOSWindows", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "isTargetELF", "(", ")", "?", "X86II", "::", "MO_GOT", ":", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOT", ";", "}", "</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", "128", "X86II::MO_ABS8", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_COFFSTUB", "X86II::MO_NO_FLAG", "X86II::MO_GOT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_NO_FLAG", "X86II::MO_GOT" ]

[]

[ "<s>", "bool", "nios2_large_constant_p", "(", "rtx", "x", ")", "{", "return", "(", "nios2_symbolic_constant_p", "(", "x", ")", "||", "nios2_large_unspec_reloc_p", "(", "x", ")", "||", "(", "CONST_INT_P", "(", "x", ")", "&&", "!", "SMALL_INT", "(", "INTVAL", "(", "x", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "something", "that", "needs", "to", "be", "split", "into", "a", "high/lo_sum", "pair", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "void", "xputenv", "(", "const", "char", "*", "string", ")", "{", "if", "(", "verbose", ")", "fprintf", "(", "stderr", ",", "\"%s\\n\"", ",", "string", ")", ";", "putenv", "(", "CONST_CAST", "(", "char", "*", ",", "string", ")", ")", ";", "}", "</s>" ]

[ "Add", "or", "change", "the", "value", "of", "an", "environment", "variable", ",", "outputting", "the", "change", "to", "standard", "error", "if", "in", "verbose", "mode", "." ]

[ "nvptx", "\"%s\\n\"" ]

[]

[ "<s>", "static", "bool", "s390_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "addr", ",", "bool", "strict", ")", "{", "struct", "s390_address", "ad", ";", "if", "(", "TARGET_Z10", "&&", "larl_operand", "(", "addr", ",", "VOIDmode", ")", "&&", "(", "mode", "==", "VOIDmode", "||", "s390_check_symref_alignment", "(", "addr", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", "return", "true", ";", "if", "(", "!", "s390_decompose_address", "(", "addr", ",", "&", "ad", ")", ")", "return", "false", ";", "if", "(", "TARGET_VX", "&&", "VECTOR_MODE_P", "(", "mode", ")", "&&", "ad", ".", "disp", "!=", "NULL_RTX", "&&", "CONST_INT_P", "(", "ad", ".", "disp", ")", "&&", "!", "SHORT_DISP_IN_RANGE", "(", "INTVAL", "(", "ad", ".", "disp", ")", ")", ")", "return", "false", ";", "if", "(", "strict", ")", "{", "if", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "return", "false", ";", "if", "(", "ad", ".", "indx", "&&", "!", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "ad", ".", "indx", ")", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "ad", ".", "base", "&&", "!", "(", "REGNO", "(", "ad", ".", "base", ")", ">=", "FIRST_PSEUDO_REGISTER", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "ad", ".", "base", ")", ")", "==", "ADDR_REGS", ")", ")", "return", "false", ";", "if", "(", "ad", ".", "indx", "&&", "!", "(", "REGNO", "(", "ad", ".", "indx", ")", ">=", "FIRST_PSEUDO_REGISTER", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "ad", ".", "indx", ")", ")", "==", "ADDR_REGS", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "is", "a", "valid", "memory", "address", ".", "STRICT", "specifies", "whether", "strict", "register", "checking", "applies", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "mips16_load_branch_target", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "TARGET_ABICALLS", "&&", "!", "TARGET_ABSOLUTE_ABICALLS", ")", "{", "rtx", "page", ",", "low", ";", "if", "(", "mips_cfun_has_cprestore_slot_p", "(", ")", ")", "mips_emit_move", "(", "dest", ",", "mips_cprestore_slot", "(", "dest", ",", "true", ")", ")", ";", "else", "mips_emit_move", "(", "dest", ",", "pic_offset_table_rtx", ")", ";", "page", "=", "mips_unspec_address", "(", "src", ",", "SYMBOL_GOTOFF_PAGE", ")", ";", "low", "=", "mips_unspec_address", "(", "src", ",", "SYMBOL_GOT_PAGE_OFST", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "PMODE_INSN", "(", "gen_unspec_got", ",", "(", "dest", ",", "page", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "dest", ",", "low", ")", ")", ")", ";", "}", "else", "{", "src", "=", "mips_unspec_address", "(", "src", ",", "SYMBOL_ABSOLUTE", ")", ";", "mips_emit_move", "(", "dest", ",", "src", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "load", "LABEL_REF", "SRC", "into", "MIPS16", "register", "DEST", ".", "This", "is", "called", "very", "late", "in", "mips_reorg", ",", "but", "the", "caller", "is", "required", "to", "run", "mips16_lay_out_constants", "on", "the", "result", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "adjust_subreg_index", "(", "rtx", "op", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "code", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", ")", ")", "{", "unsigned", "int", "index", "=", "SUBREG_BYTE", "(", "op", ")", ";", "if", "(", "index", "<", "8", ")", "index", "+=", "8", ";", "else", "index", "-=", "8", ";", "SUBREG_BYTE", "(", "op", ")", "=", "index", ";", "}", "const", "char", "*", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_RTX_LENGTH", "(", "code", ")", ";", "++", "i", ")", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "||", "fmt", "[", "i", "]", "==", "'u'", ")", "adjust_subreg_index", "(", "XEXP", "(", "op", ",", "i", ")", ")", ";", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "op", ",", "i", ")", ";", "++", "j", ")", "adjust_subreg_index", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ";", "}", "</s>" ]

[ "Find", "all", "subregs", "of", "a", "vector", "expression", "that", "perform", "a", "narrowing", ",", "and", "adjust", "the", "subreg", "index", "to", "account", "for", "doubleword", "swapping", "." ]

[ "rs6000", "0", "8", "8", "8", "0", "0" ]

[]

[ "<s>", "static", "void", "rs6000_expand_vector_set_var_p9", "(", "rtx", "target", ",", "rtx", "val", ",", "rtx", "idx", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "gcc_assert", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "CONST_INT_P", "(", "idx", ")", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE", "(", "val", ")", ";", "int", "width", "=", "GET_MODE_SIZE", "(", "inner_mode", ")", ";", "gcc_assert", "(", "width", ">=", "1", "&&", "width", "<=", "8", ")", ";", "int", "shift", "=", "exact_log2", "(", "width", ")", ";", "machine_mode", "idx_mode", "=", "GET_MODE", "(", "idx", ")", ";", "machine_mode", "shift_mode", ";", "rtx", "(", "*", "gen_ashl", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_lvsl", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_lvsr", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "TARGET_POWERPC64", ")", "{", "shift_mode", "=", "DImode", ";", "gen_ashl", "=", "gen_ashldi3", ";", "gen_lvsl", "=", "gen_altivec_lvsl_reg_di", ";", "gen_lvsr", "=", "gen_altivec_lvsr_reg_di", ";", "}", "else", "{", "shift_mode", "=", "SImode", ";", "gen_ashl", "=", "gen_ashlsi3", ";", "gen_lvsl", "=", "gen_altivec_lvsl_reg_si", ";", "gen_lvsr", "=", "gen_altivec_lvsr_reg_si", ";", "}", "rtx", "tmp", "=", "gen_reg_rtx", "(", "shift_mode", ")", ";", "idx", "=", "convert_modes", "(", "shift_mode", ",", "idx_mode", ",", "idx", ",", "1", ")", ";", "emit_insn", "(", "gen_ashl", "(", "tmp", ",", "idx", ",", "GEN_INT", "(", "shift", ")", ")", ")", ";", "rtx", "pcvr", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_lvsr", "(", "pcvr", ",", "tmp", ")", ")", ";", "rtx", "pcvl", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_lvsl", "(", "pcvl", ",", "tmp", ")", ")", ";", "rtx", "sub_target", "=", "simplify_gen_subreg", "(", "V16QImode", ",", "target", ",", "mode", ",", "0", ")", ";", "rtx", "permr", "=", "gen_altivec_vperm_v8hiv16qi", "(", "sub_target", ",", "sub_target", ",", "sub_target", ",", "pcvr", ")", ";", "emit_insn", "(", "permr", ")", ";", "rs6000_expand_vector_set", "(", "target", ",", "val", ",", "const0_rtx", ")", ";", "rtx", "perml", "=", "gen_altivec_vperm_v8hiv16qi", "(", "sub_target", ",", "sub_target", ",", "sub_target", ",", "pcvl", ")", ";", "emit_insn", "(", "perml", ")", ";", "}", "</s>" ]

[ "Insert", "VAL", "into", "IDX", "of", "TARGET", ",", "VAL", "size", "is", "same", "of", "the", "vector", "element", ",", "IDX", "is", "variable", "and", "also", "counts", "by", "vector", "element", "size", "for", "p9", "and", "above", "." ]

[ "rs6000", "1", "8", "1", "0" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUTargetLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "return", "AMDGPUCallLowering", "::", "CCAssignFnForReturn", "(", "CC", ",", "IsVarArg", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Value", "*", "GCNTTIImpl", "::", "rewriteIntrinsicWithAddressSpace", "(", "IntrinsicInst", "*", "II", ",", "Value", "*", "OldV", ",", "Value", "*", "NewV", ")", "const", "{", "auto", "IntrID", "=", "II", "->", "getIntrinsicID", "(", ")", ";", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "const", "ConstantInt", "*", "IsVolatile", "=", "cast", "<", "ConstantInt", ">", "(", "II", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "IsVolatile", "->", "isZero", "(", ")", ")", "return", "nullptr", ";", "Module", "*", "M", "=", "II", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "DestTy", "=", "II", "->", "getType", "(", ")", ";", "Type", "*", "SrcTy", "=", "NewV", "->", "getType", "(", ")", ";", "Function", "*", "NewDecl", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "II", "->", "getIntrinsicID", "(", ")", ",", "{", "DestTy", ",", "SrcTy", "}", ")", ";", "II", "->", "setArgOperand", "(", "0", ",", "NewV", ")", ";", "II", "->", "setCalledFunction", "(", "NewDecl", ")", ";", "return", "II", ";", "}", "case", "Intrinsic", "::", "amdgcn_is_shared", ":", "case", "Intrinsic", "::", "amdgcn_is_private", ":", "{", "unsigned", "TrueAS", "=", "IntrID", "==", "Intrinsic", "::", "amdgcn_is_shared", "?", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ";", "unsigned", "NewAS", "=", "NewV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "NewV", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "ConstantInt", "*", "NewVal", "=", "(", "TrueAS", "==", "NewAS", ")", "?", "ConstantInt", "::", "getTrue", "(", "Ctx", ")", ":", "ConstantInt", "::", "getFalse", "(", "Ctx", ")", ";", "return", "NewVal", ";", "}", "case", "Intrinsic", "::", "ptrmask", ":", "{", "unsigned", "OldAS", "=", "OldV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "unsigned", "NewAS", "=", "NewV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "Value", "*", "MaskOp", "=", "II", "->", "getArgOperand", "(", "1", ")", ";", "Type", "*", "MaskTy", "=", "MaskOp", "->", "getType", "(", ")", ";", "bool", "DoTruncate", "=", "false", ";", "const", "GCNTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "GCNTargetMachine", "&", ">", "(", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ")", ";", "if", "(", "!", "TM", ".", "isNoopAddrSpaceCast", "(", "OldAS", ",", "NewAS", ")", ")", "{", "if", "(", "DL", ".", "getPointerSizeInBits", "(", "OldAS", ")", "!=", "64", "||", "DL", ".", "getPointerSizeInBits", "(", "NewAS", ")", "!=", "32", ")", "return", "nullptr", ";", "KnownBits", "Known", "=", "computeKnownBits", "(", "MaskOp", ",", "DL", ",", "0", ",", "nullptr", ",", "II", ")", ";", "if", "(", "Known", ".", "countMinLeadingOnes", "(", ")", "<", "32", ")", "return", "nullptr", ";", "DoTruncate", "=", "true", ";", "}", "IRBuilder", "<", ">", "B", "(", "II", ")", ";", "if", "(", "DoTruncate", ")", "{", "MaskTy", "=", "B", ".", "getInt32Ty", "(", ")", ";", "MaskOp", "=", "B", ".", "CreateTrunc", "(", "MaskOp", ",", "MaskTy", ")", ";", "}", "return", "B", ".", "CreateIntrinsic", "(", "Intrinsic", "::", "ptrmask", ",", "{", "NewV", "->", "getType", "(", ")", ",", "MaskTy", "}", ",", "{", "NewV", ",", "MaskOp", "}", ")", ";", "}", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

[ "Rewrite", "intrinsic", "call", "II", "such", "that", "OldV", "will", "be", "replaced", "with", "NewV", ",", "which", "has", "a", "different", "address", "space", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "4", "Intrinsic::getDeclaration", "0", "Intrinsic::amdgcn_is_shared", "Intrinsic::amdgcn_is_private", "Intrinsic::amdgcn_is_shared", "AMDGPU", "AMDGPU", "Intrinsic::ptrmask", "1", "64", "32", "0", "32", "Intrinsic::ptrmask" ]

[]

[ "<s>", "DEBUG_FUNCTION", "static", "void", "debug_insn_dispatch_info_file", "(", "FILE", "*", "file", ",", "rtx_insn", "*", "insn", ")", "{", "int", "byte_len", ";", "enum", "insn_path", "path", ";", "enum", "dispatch_group", "group", ";", "int", "imm_size", ";", "int", "num_imm_operand", ";", "int", "num_imm32_operand", ";", "int", "num_imm64_operand", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "<", "0", ")", "return", ";", "byte_len", "=", "min_insn_size", "(", "insn", ")", ";", "path", "=", "get_insn_path", "(", "insn", ")", ";", "group", "=", "get_insn_group", "(", "insn", ")", ";", "imm_size", "=", "get_num_immediates", "(", "insn", ",", "&", "num_imm_operand", ",", "&", "num_imm32_operand", ",", "&", "num_imm64_operand", ")", ";", "fprintf", "(", "file", ",", "\" insn info:\\n\"", ")", ";", "fprintf", "(", "file", ",", "\" group = %s, path = %d, byte_len = %d\\n\"", ",", "group_name", "[", "group", "]", ",", "path", ",", "byte_len", ")", ";", "fprintf", "(", "file", ",", "\" num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\\n\"", ",", "num_imm_operand", ",", "num_imm32_operand", ",", "num_imm64_operand", ",", "imm_size", ")", ";", "}", "</s>" ]

[ "Print", "INSN", "dispatch", "information", "to", "FILE", "." ]

[ "i386", "0", "\" insn info:\\n\"", "\" group = %s, path = %d, byte_len = %d\\n\"", "\" num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\\n\"" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "NumBytes", "-", "1", ")", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "static_cast", "<", "uint8_t", ">", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "VE", "\"Invalid fixup offset!\"", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "static", "rtx_insn", "*", "pdp11_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "CC_REGNUM", ")", ";", "if", "(", "TARGET_FPU", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "FCC_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "FCC_REGNUM", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Prepend", "to", "CLOBBERS", "hard", "registers", "that", "are", "automatically", "clobbered", "for", "an", "asm", "We", "do", "this", "for", "CC_REGNUM", "and", "FCC_REGNUM", "(", "on", "FPU", "target", ")", "to", "maintain", "source", "compatibility", "with", "the", "original", "cc0-based", "compiler", "." ]

[ "pdp11" ]

[]

[ "<s>", "void", "SIScheduleBlockScheduler", "::", "addLiveRegs", "(", "std", "::", "set", "<", "unsigned", ">", "&", "Regs", ")", "{", "for", "(", "unsigned", "Reg", ":", "Regs", ")", "{", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "Reg", ")", ")", "continue", ";", "(", "void", ")", "LiveRegs", ".", "insert", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Force", "liveness", "of", "virtual", "registers", "or", "physical", "register", "units", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "SUnit", "*", "GCNMaxOccupancySchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "SUnit", "*", "SU", ";", "do", "{", "if", "(", "RegionPolicy", ".", "OnlyTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "CandPolicy", "NoPolicy", ";", "TopCand", ".", "reset", "(", "NoPolicy", ")", ";", "pickNodeFromQueue", "(", "Top", ",", "NoPolicy", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find a candidate\"", ")", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "RegionPolicy", ".", "OnlyBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "CandPolicy", "NoPolicy", ";", "BotCand", ".", "reset", "(", "NoPolicy", ")", ";", "pickNodeFromQueue", "(", "Bot", ",", "NoPolicy", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find a candidate\"", ")", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidirectional", "(", "IsTopNode", ")", ";", "}", "}", "while", "(", "SU", "->", "isScheduled", ")", ";", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") \"", "<<", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"ReadyQ garbage\"", "\"failed to find a candidate\"", "\"failed to find a candidate\"", "\"Scheduling SU(\"", "\") \"" ]

[]

[ "<s>", "RISCVConstantPoolValue", "*", "RISCVConstantPoolValue", "::", "Create", "(", "const", "GlobalValue", "*", "GV", ",", "RISCVCP", "::", "RISCVCPModifier", "Modifier", ")", "{", "return", "new", "RISCVConstantPoolValue", "(", "GV", ",", "Modifier", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCVCP::RISCVCPModifier", "RISCV" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "StringRef", "WinEHParentName", "=", "F", ".", "getFnAttribute", "(", "\"wineh-parent\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "WinEHParentName", "!=", "F", ".", "getName", "(", ")", "&&", "!", "WinEHParentName", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isMSVCEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "auto", "*", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "std", "::", "unique_ptr", "<", "WinEHFuncInfo", ">", "FuncInfoPtr", ";", "if", "(", "!", "MMI", ")", "FuncInfoPtr", ".", "reset", "(", "new", "WinEHFuncInfo", "(", ")", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "*", "(", "MMI", "?", "&", "MMI", "->", "getWinEHFuncInfo", "(", "&", "F", ")", ":", "FuncInfoPtr", ".", "get", "(", ")", ")", ";", "switch", "(", "Personality", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected personality function\"", ")", ";", "case", "EHPersonality", "::", "MSVC_CXX", ":", "addCXXStateStores", "(", "F", ",", "FuncInfo", ")", ";", "break", ";", "case", "EHPersonality", "::", "MSVC_X86SEH", ":", "addSEHStateStores", "(", "F", ",", "FuncInfo", ")", ";", "break", ";", "}", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"wineh-parent\"", "\"no-frame-pointer-elim\"", "\"true\"", "\"unexpected personality function\"", "X86" ]

[]

[ "<s>", "static", "const", "char", "*", "output_probe_stack_range_stack_clash", "(", "rtx", "reg1", ",", "rtx", "reg2", ",", "rtx", "reg3", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "3", "]", ";", "HOST_WIDE_INT", "probe_interval", "=", "get_stack_clash_protection_probe_interval", "(", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "reg2", ";", "xops", "[", "2", "]", "=", "GEN_INT", "(", "-", "probe_interval", ")", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\"stdu %1,%2(%0)\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"stwu %1,%2(%0)\"", ",", "xops", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "reg3", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\"cmpd 0,%0,%1\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"cmpw 0,%0,%1\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tbne 0,\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Probe", "a", "range", "of", "stack", "addresses", "from", "REG1", "to", "REG3", "inclusive", ".", "These", "are", "addresses", ",", "not", "offsets", ".", "REG2", "contains", "the", "backchain", "that", "must", "be", "stored", "into", "*", "sp", "at", "each", "allocation", ".", "This", "is", "subtly", "different", "than", "the", "Ada", "probing", "above", "in", "that", "it", "tries", "hard", "to", "prevent", "attacks", "that", "jump", "the", "stack", "guard", ".", "Thus", ",", "it", "is", "never", "allowed", "to", "allocate", "more", "than", "PROBE_INTERVAL", "bytes", "of", "stack", "space", "without", "a", "suitable", "probe", "." ]

[ "rs6000", "0", "32", "3", "\"LPSRL\"", "0", "1", "2", "\"stdu %1,%2(%0)\"", "\"stwu %1,%2(%0)\"", "0", "1", "\"cmpd 0,%0,%1\"", "\"cmpw 0,%0,%1\"", "\"\\tbne 0,\"", "\"\"" ]

[]

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

[ "Return", "true", "if", "lookup", "tables", "should", "be", "turned", "into", "relative", "lookup", "tables", "." ]

[ "VE" ]

[]

[ "<s>", "static", "enum", "machine_mode", "hfa_element_mode", "(", "tree", "type", ",", "bool", "nested", ")", "{", "enum", "machine_mode", "element_mode", "=", "VOIDmode", ";", "enum", "machine_mode", "mode", ";", "enum", "tree_code", "code", "=", "TREE_CODE", "(", "type", ")", ";", "int", "know_element_mode", "=", "0", ";", "tree", "t", ";", "if", "(", "!", "nested", "&&", "(", "!", "TYPE_SIZE", "(", "type", ")", "||", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", ")", "return", "VOIDmode", ";", "switch", "(", "code", ")", "{", "case", "VOID_TYPE", ":", "case", "INTEGER_TYPE", ":", "case", "ENUMERAL_TYPE", ":", "case", "BOOLEAN_TYPE", ":", "case", "CHAR_TYPE", ":", "case", "POINTER_TYPE", ":", "case", "OFFSET_TYPE", ":", "case", "REFERENCE_TYPE", ":", "case", "METHOD_TYPE", ":", "case", "LANG_TYPE", ":", "case", "FUNCTION_TYPE", ":", "return", "VOIDmode", ";", "case", "COMPLEX_TYPE", ":", "if", "(", "GET_MODE_CLASS", "(", "TYPE_MODE", "(", "type", ")", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "TYPE_MODE", "(", "type", ")", "!=", "TCmode", ")", "return", "GET_MODE_INNER", "(", "TYPE_MODE", "(", "type", ")", ")", ";", "else", "return", "VOIDmode", ";", "case", "REAL_TYPE", ":", "if", "(", "nested", "&&", "TYPE_MODE", "(", "type", ")", "!=", "TFmode", ")", "return", "TYPE_MODE", "(", "type", ")", ";", "else", "return", "VOIDmode", ";", "case", "ARRAY_TYPE", ":", "return", "hfa_element_mode", "(", "TREE_TYPE", "(", "type", ")", ",", "1", ")", ";", "case", "RECORD_TYPE", ":", "case", "UNION_TYPE", ":", "case", "QUAL_UNION_TYPE", ":", "for", "(", "t", "=", "TYPE_FIELDS", "(", "type", ")", ";", "t", ";", "t", "=", "TREE_CHAIN", "(", "t", ")", ")", "{", "if", "(", "TREE_CODE", "(", "t", ")", "!=", "FIELD_DECL", ")", "continue", ";", "mode", "=", "hfa_element_mode", "(", "TREE_TYPE", "(", "t", ")", ",", "1", ")", ";", "if", "(", "know_element_mode", ")", "{", "if", "(", "mode", "!=", "element_mode", ")", "return", "VOIDmode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", ")", "return", "VOIDmode", ";", "else", "{", "know_element_mode", "=", "1", ";", "element_mode", "=", "mode", ";", "}", "}", "return", "element_mode", ";", "default", ":", "return", "VOIDmode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "Check", "whether", "TYPE", "is", "a", "homogeneous", "floating", "point", "aggregate", ".", "If", "it", "is", ",", "return", "the", "mode", "of", "the", "floating", "point", "type", "that", "appears", "in", "all", "leafs", ".", "If", "it", "is", "not", ",", "return", "VOIDmode", ".", "An", "aggregate", "is", "a", "homogeneous", "floating", "point", "aggregate", "is", "if", "all", "fields/elements", "in", "it", "have", "the", "same", "floating", "point", "type", "(", "e.g", ",", "SFmode", ")", ".", "128-bit", "quad-precision", "floats", "are", "excluded", "." ]

[ "ia64", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "report_not_enum", "(", "location_t", "location", ",", "tree", "fndecl", ",", "unsigned", "int", "argno", ",", "HOST_WIDE_INT", "actual", ",", "tree", "enumtype", ")", "{", "error_at", "(", "location", ",", "\"passing %wd to argument %d of %qE, which expects\"", "\" a valid %qT value\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "enumtype", ")", ";", "}", "</s>" ]

[ "Report", "that", "LOCATION", "has", "a", "call", "to", "FNDECL", "in", "which", "argument", "ARGNO", "has", "the", "value", "ACTUAL", ",", "whereas", "the", "function", "requires", "a", "valid", "value", "of", "enum", "type", "ENUMTYPE", ".", "ARGNO", "counts", "from", "zero", "." ]

[ "aarch64", "\"passing %wd to argument %d of %qE, which expects\"", "\" a valid %qT value\"", "1" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_value", "(", "HOST_WIDE_INT", "val", ",", "unsigned", "int", "size", ")", "{", "unsigned", "HOST_WIDE_INT", "chunk_offset", "=", "decl_offset", "%", "decl_chunk_size", ";", "gcc_assert", "(", "!", "object_finished", ")", ";", "while", "(", "size", ">", "0", ")", "{", "int", "this_part", "=", "size", ";", "if", "(", "chunk_offset", "+", "this_part", ">", "decl_chunk_size", ")", "this_part", "=", "decl_chunk_size", "-", "chunk_offset", ";", "HOST_WIDE_INT", "val_part", ";", "HOST_WIDE_INT", "mask", "=", "2", ";", "mask", "<<=", "this_part", "*", "BITS_PER_UNIT", "-", "1", ";", "val_part", "=", "val", "&", "(", "mask", "-", "1", ")", ";", "init_part", "|=", "val_part", "<<", "(", "BITS_PER_UNIT", "*", "chunk_offset", ")", ";", "val", ">>=", "BITS_PER_UNIT", "*", "this_part", ";", "size", "-=", "this_part", ";", "decl_offset", "+=", "this_part", ";", "if", "(", "decl_offset", "%", "decl_chunk_size", "==", "0", ")", "output_decl_chunk", "(", ")", ";", "chunk_offset", "=", "0", ";", "}", "}", "</s>" ]

[ "Add", "value", "VAL", "sized", "SIZE", "to", "the", "data", "we", "'re", "emitting", ",", "and", "keep", "writing", "out", "chunks", "as", "they", "fill", "up", "." ]

[ "nvptx", "0", "2", "1", "1", "0", "0" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "static", "bool", "ix86_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE_INNER", "(", "mode", ")", "==", "TImode", ")", "return", "false", ";", "if", "(", "TARGET_SSE", "&&", "VALID_SSE_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_SSE2", "&&", "VALID_SSE2_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX", "&&", "VALID_AVX256_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX512F", "&&", "VALID_AVX512F_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_MMX", "||", "TARGET_MMX_WITH_SSE", ")", "&&", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_3DNOW", "||", "TARGET_MMX_WITH_SSE", ")", "&&", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "mode", "==", "V2QImode", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "i386" ]

[]

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

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

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

[]

[ "<s>", "enum", "non_prefixed_form", "reg_to_non_prefixed", "(", "rtx", "reg", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "REG_P", "(", "reg", ")", "&&", "!", "SUBREG_P", "(", "reg", ")", ")", "return", "NON_PREFIXED_DEFAULT", ";", "unsigned", "int", "r", "=", "reg_or_subregno", "(", "reg", ")", ";", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "r", ")", ")", "return", "NON_PREFIXED_DEFAULT", ";", "unsigned", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "size", "==", "8", "||", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "NON_PREFIXED_D", ";", "else", "if", "(", "size", "<", "8", ")", "return", "NON_PREFIXED_X", ";", "else", "if", "(", "TARGET_VSX", "&&", "size", ">=", "16", "&&", "(", "VECTOR_MODE_P", "(", "mode", ")", "||", "VECTOR_ALIGNMENT_P", "(", "mode", ")", "||", "mode", "==", "TImode", "||", "mode", "==", "CTImode", ")", ")", "return", "(", "TARGET_P9_VECTOR", ")", "?", "NON_PREFIXED_DQ", ":", "NON_PREFIXED_X", ";", "else", "return", "NON_PREFIXED_DEFAULT", ";", "}", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "!", "TARGET_P9_VECTOR", ")", "return", "NON_PREFIXED_X", ";", "if", "(", "mode", "==", "SFmode", "||", "size", "==", "8", "||", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "NON_PREFIXED_DS", ";", "else", "if", "(", "size", "<", "8", ")", "return", "NON_PREFIXED_X", ";", "else", "if", "(", "TARGET_VSX", "&&", "size", ">=", "16", "&&", "(", "VECTOR_MODE_P", "(", "mode", ")", "||", "VECTOR_ALIGNMENT_P", "(", "mode", ")", "||", "mode", "==", "TImode", "||", "mode", "==", "CTImode", ")", ")", "return", "NON_PREFIXED_DQ", ";", "else", "return", "NON_PREFIXED_DEFAULT", ";", "}", "else", "if", "(", "TARGET_POWERPC64", "&&", "size", ">=", "8", ")", "return", "NON_PREFIXED_DS", ";", "return", "NON_PREFIXED_D", ";", "}", "</s>" ]

[ "Helper", "function", "to", "take", "a", "REG", "and", "a", "MODE", "and", "turn", "it", "into", "the", "non-prefixed", "instruction", "format", "(", "D/DS/DQ", ")", "used", "for", "offset", "memory", "." ]

[ "rs6000", "8", "8", "16", "8", "8", "16", "8" ]

[]

[ "<s>", "static", "bool", "rs6000_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_TOCREL", ":", "gcc_checking_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "REG_P", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "&&", "REGNO", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "==", "TOC_REGISTER", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "if", "(", "x", "==", "tocrel_base", "&&", "tocrel_offset", "!=", "const0_rtx", ")", "{", "if", "(", "INTVAL", "(", "tocrel_offset", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_offset", ")", ")", ";", "}", "if", "(", "!", "TARGET_AIX", "||", "(", "TARGET_ELF", "&&", "TARGET_MINIMAL_TOC", ")", ")", "{", "putc", "(", "'-'", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "toc_label_name", ")", ";", "}", "else", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@toc\"", ",", "file", ")", ";", "return", "true", ";", "case", "UNSPEC_MACHOPIC_OFFSET", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "putc", "(", "'-'", ",", "file", ")", ";", "machopic_output_function_base_name", "(", "file", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "rs6000", "1", "0", "0", "0", "1", "0", "1", "0", "0", "0", "\"+\"", "\"@toc\"", "0", "0" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_Mips", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips" ]

[]

[ "<s>", "int", "ix86_issue_rate", "(", "void", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "case", "PROCESSOR_LAKEMONT", ":", "case", "PROCESSOR_BONNELL", ":", "case", "PROCESSOR_SILVERMONT", ":", "case", "PROCESSOR_KNL", ":", "case", "PROCESSOR_KNM", ":", "case", "PROCESSOR_INTEL", ":", "case", "PROCESSOR_K6", ":", "case", "PROCESSOR_BTVER2", ":", "case", "PROCESSOR_PENTIUM4", ":", "case", "PROCESSOR_NOCONA", ":", "return", "2", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "case", "PROCESSOR_ATHLON", ":", "case", "PROCESSOR_K8", ":", "case", "PROCESSOR_AMDFAM10", ":", "case", "PROCESSOR_BTVER1", ":", "return", "3", ";", "case", "PROCESSOR_BDVER1", ":", "case", "PROCESSOR_BDVER2", ":", "case", "PROCESSOR_BDVER3", ":", "case", "PROCESSOR_BDVER4", ":", "case", "PROCESSOR_ZNVER1", ":", "case", "PROCESSOR_ZNVER2", ":", "case", "PROCESSOR_ZNVER3", ":", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "case", "PROCESSOR_TREMONT", ":", "case", "PROCESSOR_ALDERLAKE", ":", "case", "PROCESSOR_GENERIC", ":", "return", "4", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "instructions", "a", "cpu", "can", "issue", "." ]

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

[]

[ "<s>", "void", "F2003fInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "F2003f", "F2003f" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"Code size not handled.\"", ")", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"ARC branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "ARC", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "int", "BccOpc", "=", "Cond", "[", "1", "]", ".", "isImm", "(", ")", "?", "ARC", "::", "BRcc_ru6_p", ":", "ARC", "::", "BRcc_rr_p", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BccOpc", ")", ")", ";", "MIB", ".", "addMBB", "(", "TBB", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "MIB", ".", "add", "(", "Cond", "[", "i", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "{", "return", "1", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "ARC", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "ARC", "ARC", "\"Code size not handled.\"", "\"insertBranch must not be told to insert a fallthrough\"", "3", "0", "\"ARC branch conditions have two components!\"", "ARC::BR", "1", "1", "ARC::BRcc_ru6_p", "ARC::BRcc_rr_p", "0", "3", "1", "ARC::BR", "2" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "MSP430TargetLowering", "::", "getConstraintType", "(", "StringRef", "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", "." ]

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

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TPC Software Loop Pipelining\"", ";", "}", "</s>" ]

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

[ "TPC", "\"TPC Software Loop Pipelining\"" ]

[]

[ "<s>", "static", "void", "replace_auli_pcrel", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "set_src", ";", "rtx", "high", ";", "rtx", "unspec", ";", "rtx", "opnds", "[", "4", "]", ";", "bool", "first_insn_p", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "opnds", "[", "0", "]", "=", "SET_DEST", "(", "pattern", ")", ";", "set_src", "=", "SET_SRC", "(", "pattern", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set_src", ")", "==", "PLUS", ")", ";", "opnds", "[", "1", "]", "=", "XEXP", "(", "set_src", ",", "0", ")", ";", "high", "=", "XEXP", "(", "set_src", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "high", ")", "==", "HIGH", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "high", ",", "0", ")", ")", "==", "CONST", ")", ";", "unspec", "=", "XEXP", "(", "XEXP", "(", "high", ",", "0", ")", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "gcc_assert", "(", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_PCREL_SYM", ")", ";", "opnds", "[", "2", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "opnds", "[", "3", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "opnds", "[", "2", "]", ")", "!=", "SYMBOL_REF", ")", "return", ";", "first_insn_p", "=", "(", "opnds", "[", "1", "]", "==", "tilepro_text_label_rtx", "(", ")", ")", ";", "replace_pc_relative_symbol_ref", "(", "insn", ",", "opnds", ",", "first_insn_p", ")", ";", "}", "</s>" ]

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

[ "tilepro", "4", "0", "1", "0", "1", "0", "0", "0", "1", "2", "0", "0", "3", "0", "1", "2", "1" ]

[]

[ "<s>", "static", "int", "arm_compute_static_chain_stack_bytes", "(", "void", ")", "{", "if", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", "&&", "IS_NESTED", "(", "arm_current_func_type", "(", ")", ")", "&&", "arm_r3_live_at_start_p", "(", ")", "&&", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", ")", "return", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "bytes", "used", "to", "store", "the", "static", "chain", "register", "on", "the", "stack", ",", "above", "the", "stack", "frame", ".", "We", "need", "to", "know", "this", "accurately", "to", "get", "the", "alignment", "of", "the", "rest", "of", "the", "stack", "frame", "correct", "." ]

[ "arm", "0", "4", "0" ]

[]

[ "<s>", "static", "void", "nios2_asm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "if", "(", "flag_pic", ")", "nios2_load_pic_register", "(", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIRST_ARG_REGNO", "+", "1", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIRST_ARG_REGNO", ")", ";", "nios2_emit_add_constant", "(", "this_rtx", ",", "delta", ")", ";", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "nios2_emit_add_constant", "(", "tmp", ",", "vcall_offset", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "nios2_adjust_call_address", "(", "&", "funexp", ",", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall_internal", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", "." ]

[ "nios2", "1", "1", "2", "1", "0", "2", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "NVPTXTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "nvvm_atomic_load_add_f32", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "f32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "vol", "=", "0", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "Info", ".", "align", "=", "0", ";", "return", "true", ";", "case", "Intrinsic", "::", "nvvm_atomic_load_inc_32", ":", "case", "Intrinsic", "::", "nvvm_atomic_load_dec_32", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "vol", "=", "0", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "Info", ".", "align", "=", "0", ";", "return", "true", ";", "case", "Intrinsic", "::", "nvvm_ldu_global_i", ":", "case", "Intrinsic", "::", "nvvm_ldu_global_f", ":", "case", "Intrinsic", "::", "nvvm_ldu_global_p", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "if", "(", "Intrinsic", "==", "Intrinsic", "::", "nvvm_ldu_global_i", ")", "Info", ".", "memVT", "=", "getValueType", "(", "I", ".", "getType", "(", ")", ")", ";", "else", "if", "(", "Intrinsic", "==", "Intrinsic", "::", "nvvm_ldu_global_p", ")", "Info", ".", "memVT", "=", "getValueType", "(", "I", ".", "getType", "(", ")", ")", ";", "else", "Info", ".", "memVT", "=", "MVT", "::", "f32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "vol", "=", "0", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "Info", ".", "align", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "Intrinsic::nvvm_atomic_load_add_f32", "ISD::INTRINSIC_W_CHAIN", "MVT::f32", "0", "0", "0", "0", "Intrinsic::nvvm_atomic_load_inc_32", "Intrinsic::nvvm_atomic_load_dec_32", "ISD::INTRINSIC_W_CHAIN", "MVT::i32", "0", "0", "0", "0", "Intrinsic::nvvm_ldu_global_i", "Intrinsic::nvvm_ldu_global_f", "Intrinsic::nvvm_ldu_global_p", "ISD::INTRINSIC_W_CHAIN", "Intrinsic::nvvm_ldu_global_i", "Intrinsic::nvvm_ldu_global_p", "MVT::f32", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "AGCMCELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AGC", "::", "DirectiveBLOCK", ":", "{", "int64_t", "ImmOp", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "StringRef", "SectionName", "=", "ImmOp", "==", "0", "?", "\"BLOCK0\"", ":", "(", "\"BANK\"", "+", "itostr", "(", "ImmOp", ")", ")", ";", "MCSection", "*", "Section", "=", "(", "(", "MCSection", "*", ")", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ")", ";", "SwitchSection", "(", "Section", ",", "nullptr", ")", ";", "return", ";", "}", "case", "AGC", "::", "DirectiveBANK", ":", "{", "StringRef", "SectionName", "=", "\"BANK\"", "+", "itostr", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ";", "MCSection", "*", "Section", "=", "(", "(", "MCSection", "*", ")", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ")", ";", "SwitchSection", "(", "Section", ",", "nullptr", ")", ";", "return", ";", "}", "case", "AGC", "::", "DirectiveBNKSUM", ":", "{", "return", ";", "}", "case", "AGC", "::", "DirectiveSETLOC", ":", "{", "StringRef", "SectionName", "=", "\"ADDR\"", "+", "itostr", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ";", "MCSection", "*", "Section", "=", "(", "(", "MCSection", "*", ")", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ")", ";", "SwitchSection", "(", "Section", ",", "nullptr", ")", ";", "return", ";", "}", "}", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "AGC::DirectiveBLOCK", "0", "0", "\"BLOCK0\"", "\"BANK\"", "AGC::DirectiveBANK", "\"BANK\"", "0", "AGC::DirectiveBNKSUM", "AGC::DirectiveSETLOC", "\"ADDR\"", "0" ]

[]

[ "<s>", "bool", "h8300_operands_match_p", "(", "rtx", "*", "operands", ")", "{", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "VOIDmode", ")", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", ")", "return", "true", ";", "if", "(", "h8sx_mergeable_memrefs_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OPERANDS", "[", "1", "]", "can", "be", "mapped", "to", "the", "same", "assembly", "operand", "as", "OPERANDS", "[", "0", "]", "." ]

[ "h8300", "0", "1", "0", "1" ]

[]

[ "<s>", "SDValue", "XtensaTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Custom lowering: \"", ")", ";", "LLVM_DEBUG", "(", "Op", ".", "dump", "(", ")", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Custom lowering: \"", "ISD::BR_CC", "\"unimplemented operand\"" ]

[]

[ "<s>", "static", "rtx", "find_addr_reg", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Return", "a", "REG", "that", "occurs", "in", "ADDR", "with", "coefficient", "1", ".", "ADDR", "can", "be", "effectively", "incremented", "by", "incrementing", "REG", ".", "r0", "is", "special", "and", "we", "must", "not", "select", "it", "as", "an", "address", "register", "by", "this", "routine", "since", "our", "caller", "will", "try", "to", "increment", "the", "returned", "register", "via", "an", "``", "la", "''", "instruction", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_discover_homogeneous_aggregate", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "elt_mode", ",", "int", "*", "n_elts", ")", "{", "if", "(", "TARGET_HARD_FLOAT", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "machine_mode", "field_mode", "=", "VOIDmode", ";", "int", "field_count", "=", "rs6000_aggregate_candidate", "(", "type", ",", "&", "field_mode", ")", ";", "if", "(", "field_count", ">", "0", ")", "{", "int", "reg_size", "=", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "field_mode", ")", "?", "16", ":", "8", ";", "int", "field_size", "=", "ROUND_UP", "(", "GET_MODE_SIZE", "(", "field_mode", ")", ",", "reg_size", ")", ";", "if", "(", "field_count", "*", "field_size", "<=", "AGGR_ARG_NUM_REG", "*", "reg_size", ")", "{", "if", "(", "elt_mode", ")", "*", "elt_mode", "=", "field_mode", ";", "if", "(", "n_elts", ")", "*", "n_elts", "=", "field_count", ";", "return", "true", ";", "}", "}", "}", "if", "(", "elt_mode", ")", "*", "elt_mode", "=", "mode", ";", "if", "(", "n_elts", ")", "*", "n_elts", "=", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "an", "argument", ",", "whose", "type", "is", "described", "by", "TYPE", "and", "MODE", ",", "is", "a", "homogeneous", "float", "or", "vector", "aggregate", "that", "shall", "be", "passed", "in", "FP/vector", "registers", "according", "to", "the", "ELFv2", "ABI", ",", "return", "the", "homogeneous", "element", "mode", "in", "*", "ELT_MODE", "and", "the", "number", "of", "elements", "in", "*", "N_ELTS", ",", "and", "return", "TRUE", ".", "Otherwise", ",", "set", "*", "ELT_MODE", "to", "MODE", "and", "*", "N_ELTS", "to", "1", ",", "and", "return", "FALSE", "." ]

[ "rs6000", "0", "16", "8", "1" ]

[]

[ "<s>", "int", "direct_return", "(", "void", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "FALSE", ";", "if", "(", "M32R_INTERRUPT_P", "(", "m32r_compute_function_type", "(", "current_function_decl", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "m32r_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "return", "current_frame_info", ".", "total_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

[ "m32r", "0" ]

[]

[ "<s>", "rtx", "mep_mulr_source", "(", "rtx_insn", "*", "insn", ",", "rtx", "dest", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "if", "(", "rtx_equal_p", "(", "dest", ",", "src1", ")", ")", "return", "src2", ";", "else", "if", "(", "rtx_equal_p", "(", "dest", ",", "src2", ")", ")", "return", "src1", ";", "else", "{", "if", "(", "insn", "==", "0", ")", "emit_insn", "(", "gen_movsi", "(", "copy_rtx", "(", "dest", ")", ",", "src1", ")", ")", ";", "else", "emit_insn_before", "(", "gen_movsi", "(", "copy_rtx", "(", "dest", ")", ",", "src1", ")", ",", "insn", ")", ";", "return", "src2", ";", "}", "}", "</s>" ]

[ "Given", "three", "integer", "registers", "DEST", ",", "SRC1", "and", "SRC2", ",", "return", "an", "rtx", "X", "such", "that", "``", "mulr", "DEST", ",", "X", "''", "will", "calculate", "DEST", "=", "SRC1", "*", "SRC2", ".", "If", "a", "move", "is", "needed", ",", "emit", "it", "before", "INSN", "if", "INSN", "is", "nonnull", ",", "otherwise", "emit", "it", "at", "the", "end", "of", "the", "insn", "stream", "." ]

[ "mep", "0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "void", "frv_io_check_address", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx", "*", "other", "=", "(", "rtx", "*", ")", "data", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "*", "other", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "x", ",", "*", "other", ")", ")", "*", "other", "=", "0", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "for", "which", "DATA", "points", "to", "an", "rtx", ".", "Nullify", "*", "DATA", "if", "X", "is", "a", "register", "and", "*", "DATA", "depends", "on", "X", "." ]

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

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "return", "false", ";", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "true", ";", "if", "(", "HasAlloca", "||", "HasExtraAlign", ")", "return", "true", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", ">", "0", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "TM", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "!", "EliminateFramePointer", ")", "return", "true", ";", "if", "(", "EnableStackOVFSanitizer", ")", "return", "true", ";", "}", "const", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "HMFI", ".", "hasClobberLR", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "m68k_function_arg", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "On", "the", "m68k", "all", "args", "are", "always", "pushed", "." ]

[ "m68k" ]

[]

[ "<s>", "void", "J2RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIdx", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "auto", "isCalleeSaved", "=", "isCalleeSavedIndex", "(", "FrameIdx", ",", "MF", ".", "getFrameInfo", "(", ")", ")", ";", "unsigned", "BaseReg", "=", "isCalleeSaved", "?", "J2", "::", "R15", ":", "getFrameRegister", "(", "MF", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "}", "</s>" ]

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

[ "J2", "J2", "J2::R15" ]

[]

[ "<s>", "bool", "aarch64_return_address_signing_enabled", "(", "void", ")", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame", ".", "laid_out", ")", ";", "return", "(", "aarch64_ra_sign_scope", "==", "AARCH64_FUNCTION_ALL", "||", "(", "aarch64_ra_sign_scope", "==", "AARCH64_FUNCTION_NON_LEAF", "&&", "known_ge", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "LR_REGNUM", "]", ",", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "return", "address", "signing", "should", "be", "enabled", "for", "the", "current", "function", ",", "otherwise", "return", "FALSE", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "ARMLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "TL", "=", "TM", ".", "getTargetLowering", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "STI", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "RS", "=", "new", "RegScavenger", "(", ")", ";", "isThumb2", "=", "AFI", "->", "isThumb2Function", "(", ")", ";", "isThumb1", "=", "AFI", "->", "isThumbFunction", "(", ")", "&&", "!", "isThumb2", ";", "if", "(", "isThumb1", ")", "{", "delete", "RS", ";", "return", "false", ";", "}", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "LoadStoreMultipleOpti", "(", "MBB", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "hasV5TOps", "(", ")", ")", "Modified", "|=", "MergeReturnIntoLDM", "(", "MBB", ")", ";", "}", "delete", "RS", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "ZERO", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "FP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "BP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "||", "FuncInfo", "->", "usesTOCBasePtr", "(", ")", "||", "MF", ".", "hasInlineAsm", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "if", "(", "TFI", "->", "needsFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R31", ")", ";", "bool", "IsPositionIndependent", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "TM", ".", "isPPC64", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R29", ")", ";", "else", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "TM", ".", "isPPC64", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::FP", "PPC::BP", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC", "PPC", "PPC", "PPC::R2", "PPC::R13", "PPC::R2", "PPC", "PPC::R13", "PPC::R31", "PPC", "PPC::R29", "PPC::R30", "PPC", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "0", ",", "0", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "!=", "1", ")", "return", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'Z'", ":", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ";", "if", "(", "!", "C", ")", "return", ";", "uint64_t", "CVal", "=", "C", "->", "getZExtValue", "(", ")", ";", "uint32_t", "Bits", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented C_Other constraint\"", ")", ";", "case", "'I'", ":", "if", "(", "CVal", "<=", "0xfff", ")", "break", ";", "return", ";", "case", "'K'", ":", "if", "(", "A64Imms", "::", "isLogicalImm", "(", "32", ",", "CVal", ",", "Bits", ")", ")", "break", ";", "return", ";", "case", "'L'", ":", "if", "(", "A64Imms", "::", "isLogicalImm", "(", "64", ",", "CVal", ",", "Bits", ")", ")", "break", ";", "return", ";", "case", "'Z'", ":", "if", "(", "CVal", "==", "0", ")", "break", ";", "return", ";", "}", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CVal", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "case", "'S'", ":", "{", "if", "(", "const", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "GA", "->", "getValueType", "(", "0", ")", ")", ";", "}", "else", "if", "(", "const", "BlockAddressSDNode", "*", "BA", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetBlockAddress", "(", "BA", "->", "getBlockAddress", "(", ")", ",", "BA", "->", "getValueType", "(", "0", ")", ")", ";", "}", "else", "if", "(", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetExternalSymbol", "(", "ES", "->", "getSymbol", "(", ")", ",", "ES", "->", "getValueType", "(", "0", ")", ")", ";", "}", "else", "return", ";", "break", ";", "}", "case", "'Y'", ":", "if", "(", "const", "ConstantFPSDNode", "*", "CFP", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "CFP", "->", "isExactlyValue", "(", "0.0", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstantFP", "(", "0.0", ",", "CFP", "->", "getValueType", "(", "0", ")", ")", ";", "break", ";", "}", "}", "return", ";", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "0", "1", "0", "0", "\"Unimplemented C_Other constraint\"", "0xfff", "32", "64", "0", "0", "0", "0", "0.0", "0.0", "0" ]

[]

[ "<s>", "int", "mips_register_move_cost", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "enum", "reg_class", "to", ",", "enum", "reg_class", "from", ")", "{", "if", "(", "from", "==", "M16_REGS", "&&", "GR_REG_CLASS_P", "(", "to", ")", ")", "return", "2", ";", "else", "if", "(", "from", "==", "M16_NA_REGS", "&&", "GR_REG_CLASS_P", "(", "to", ")", ")", "return", "2", ";", "else", "if", "(", "GR_REG_CLASS_P", "(", "from", ")", ")", "{", "if", "(", "to", "==", "M16_REGS", ")", "return", "2", ";", "else", "if", "(", "to", "==", "M16_NA_REGS", ")", "return", "2", ";", "else", "if", "(", "GR_REG_CLASS_P", "(", "to", ")", ")", "{", "if", "(", "TARGET_MIPS16", ")", "return", "4", ";", "else", "return", "2", ";", "}", "else", "if", "(", "to", "==", "FP_REGS", ")", "return", "4", ";", "else", "if", "(", "reg_class_subset_p", "(", "to", ",", "ACC_REGS", ")", ")", "{", "if", "(", "TARGET_MIPS16", ")", "return", "12", ";", "else", "return", "6", ";", "}", "else", "if", "(", "COP_REG_CLASS_P", "(", "to", ")", ")", "{", "return", "5", ";", "}", "}", "else", "if", "(", "from", "==", "FP_REGS", ")", "{", "if", "(", "GR_REG_CLASS_P", "(", "to", ")", ")", "return", "4", ";", "else", "if", "(", "to", "==", "FP_REGS", ")", "return", "2", ";", "else", "if", "(", "to", "==", "ST_REGS", ")", "return", "8", ";", "}", "else", "if", "(", "reg_class_subset_p", "(", "from", ",", "ACC_REGS", ")", ")", "{", "if", "(", "GR_REG_CLASS_P", "(", "to", ")", ")", "{", "if", "(", "TARGET_MIPS16", ")", "return", "12", ";", "else", "return", "6", ";", "}", "}", "else", "if", "(", "from", "==", "ST_REGS", "&&", "GR_REG_CLASS_P", "(", "to", ")", ")", "return", "4", ";", "else", "if", "(", "COP_REG_CLASS_P", "(", "from", ")", ")", "{", "return", "5", ";", "}", "return", "12", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", ".", "Return", "0", "for", "classes", "that", "are", "the", "maximum", "of", "the", "move", "costs", "for", "subclasses", ";", "regclass", "will", "work", "out", "the", "maximum", "for", "us", "." ]

[ "mips", "2", "2", "2", "2", "4", "2", "4", "12", "6", "5", "4", "2", "8", "12", "6", "4", "5", "12" ]

[]

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

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

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

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "getZero", "(", "const", "SDLoc", "&", "dl", ",", "MVT", "Ty", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Ty", ".", "isVector", "(", ")", ")", "{", "unsigned", "W", "=", "Ty", ".", "getSizeInBits", "(", ")", ";", "if", "(", "W", "<=", "64", ")", "return", "DAG", ".", "getBitcast", "(", "Ty", ",", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "MVT", "::", "getIntegerVT", "(", "W", ")", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SPLAT_VECTOR", ",", "dl", ",", "Ty", ",", "getZero", "(", "dl", ",", "MVT", "::", "i32", ",", "DAG", ")", ")", ";", "}", "if", "(", "Ty", ".", "isInteger", "(", ")", ")", "return", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "Ty", ")", ";", "if", "(", "Ty", ".", "isFloatingPoint", "(", ")", ")", "return", "DAG", ".", "getConstantFP", "(", "0.0", ",", "dl", ",", "Ty", ")", ";", "llvm_unreachable", "(", "\"Invalid type for zero\"", ")", ";", "}", "</s>" ]

[ "Return", "a", "SCEV", "for", "the", "constant", "0", "of", "a", "specific", "type", "." ]

[ "Hexagon", "Hexagon", "64", "0", "MVT::getIntegerVT", "ISD::SPLAT_VECTOR", "MVT::i32", "0", "0.0", "\"Invalid type for zero\"" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "ReplaceTailWithBranchTo", "(", "MachineBasicBlock", "::", "iterator", "Tail", ",", "MachineBasicBlock", "*", "NewDest", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "Tail", "->", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasITBlocks", "(", ")", ")", "{", "TargetInstrInfoImpl", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "return", ";", "}", "unsigned", "PredReg", "=", "0", ";", "ARMCC", "::", "CondCodes", "CC", "=", "llvm", "::", "getInstrPredicate", "(", "Tail", ",", "PredReg", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Tail", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "--", "MBBI", ";", "TargetInstrInfoImpl", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "{", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", "->", "begin", "(", ")", ";", "unsigned", "Count", "=", "4", ";", "while", "(", "Count", "&&", "MBBI", "!=", "E", ")", "{", "if", "(", "MBBI", "->", "isDebugValue", "(", ")", ")", "{", "--", "MBBI", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Count", "==", "4", ")", "MBBI", "->", "eraseFromParent", "(", ")", ";", "else", "{", "unsigned", "MaskOn", "=", "1", "<<", "Count", ";", "unsigned", "MaskOff", "=", "~", "(", "MaskOn", "-", "1", ")", ";", "MBBI", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "(", "Mask", "&", "MaskOff", ")", "|", "MaskOn", ")", ";", "}", "return", ";", "}", "--", "MBBI", ";", "--", "Count", ";", "}", "}", "}", "</s>" ]

[ "Delete", "the", "instruction", "OldInst", "and", "everything", "after", "it", ",", "replacing", "it", "with", "an", "unconditional", "branch", "to", "NewDest", "." ]

[ "ARM", "ARM", "ARM", "0", "ARMCC::CondCodes", "ARMCC::AL", "ARMCC::AL", "4", "ARM::t2IT", "1", "4", "1", "1", "1" ]

[]

[ "<s>", "bool", "arm_pad_arg_upward", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "!", "TARGET_AAPCS_BASED", ")", "return", "DEFAULT_FUNCTION_ARG_PADDING", "(", "mode", ",", "type", ")", "==", "upward", ";", "if", "(", "type", "&&", "BYTES_BIG_ENDIAN", "&&", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "For", "use", "by", "FUNCTION_ARG_PADDING", "(", "MODE", ",", "TYPE", ")", ".", "Return", "true", "if", "an", "argument", "passed", "on", "the", "stack", "should", "be", "padded", "upwards", ",", "i.e", ".", "if", "the", "least-significant", "byte", "has", "useful", "data", ".", "For", "legacy", "APCS", "ABIs", "we", "use", "the", "default", ".", "For", "AAPCS", "based", "ABIs", "small", "aggregate", "types", "are", "placed", "in", "the", "lowest", "memory", "address", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "MSP430TargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "return", "isZExtFree", "(", "Val", ".", "getValueType", "(", ")", ",", "VT2", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasAVX512", "(", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "bool", "FnHasLiveInYmm", "=", "checkFnHasLiveInYmm", "(", "MRI", ")", ";", "bool", "YMMUsed", "=", "FnHasLiveInYmm", ";", "if", "(", "!", "YMMUsed", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "&", "X86", "::", "VR256RegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "!", "YMMUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "*", "I", ")", ";", "if", "(", "FnHasLiveInYmm", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "addDirtySuccessor", "(", "*", "*", "SI", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR256RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "Align", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte loads from stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created load reg=\"", "<<", "PrintReg", "(", "DestReg", ",", "TRI", ")", "<<", "\" from FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "LD_rs9", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte loads from stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created load reg=\"", "\" from FrameIndex=\"", "\"\\n\"", "ARC::LD_rs9", "0" ]

[]

[ "<s>", "void", "PatmosPostRASchedStrategy", "::", "finalize", "(", "ScheduleDAGPostRA", "*", "dag", ")", "{", "DAG", "=", "NULL", ";", "}", "</s>" ]

[ "Analyze", "the", "strings", "and", "build", "the", "final", "table", "." ]

[ "Patmos", "Patmos" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "computeKnownBitsForFrameIndex", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "TargetLowering", "::", "computeKnownBitsForFrameIndex", "(", "Op", ",", "Known", ",", "DemandedElts", ",", "DAG", ",", "Depth", ")", ";", "if", "(", "getSubtarget", "(", ")", "->", "enableHugePrivateBuffer", "(", ")", ")", "return", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "AssumeFrameIndexHighZeroBits", ")", ";", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "of", "FrameIndex", "FIOp", "are", "known", "to", "be", "0", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "unsigned", "assignCustomValue", "(", "ARMCallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ",", "std", "::", "function", "<", "void", "(", ")", ">", "*", "Thunk", ")", "override", "{", "assert", "(", "Arg", ".", "Regs", ".", "size", "(", ")", "==", "1", "&&", "\"Can't handle multple regs yet\"", ")", ";", "CCValAssign", "VA", "=", "VAs", "[", "0", "]", ";", "assert", "(", "VA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "!=", "MVT", "::", "f64", ")", "return", "0", ";", "CCValAssign", "NextVA", "=", "VAs", "[", "1", "]", ";", "assert", "(", "NextVA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "NextVA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "assert", "(", "VA", ".", "getValNo", "(", ")", "==", "NextVA", ".", "getValNo", "(", ")", "&&", "\"Values belong to different arguments\"", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "assert", "(", "NextVA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "Register", "NewRegs", "[", "]", "=", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ",", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", "}", ";", "assignValueToReg", "(", "NewRegs", "[", "0", "]", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ")", ";", "assignValueToReg", "(", "NewRegs", "[", "1", "]", ",", "NextVA", ".", "getLocReg", "(", ")", ",", "NextVA", ")", ";", "bool", "IsLittle", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isLittle", "(", ")", ";", "if", "(", "!", "IsLittle", ")", "std", "::", "swap", "(", "NewRegs", "[", "0", "]", ",", "NewRegs", "[", "1", "]", ")", ";", "MIRBuilder", ".", "buildMerge", "(", "Arg", ".", "Regs", "[", "0", "]", ",", "NewRegs", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Handle", "custom", "values", ",", "which", "may", "be", "passed", "into", "one", "or", "more", "of", "VAs", "." ]

[ "ARM", "ARM", "1", "\"Can't handle multple regs yet\"", "0", "\"Value doesn't need custom handling\"", "MVT::f64", "0", "1", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "\"Values belong to different arguments\"", "\"Value should be in reg\"", "\"Value should be in reg\"", "32", "32", "0", "1", "ARM", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasPassPointeeByValueAttr", "(", ")", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArgInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArgInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArgInfo", ",", "SplitArgInfos", ",", "MF", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "8", "0" ]

[]

[ "<s>", "const", "char", "*", "avr_out_addto_sp", "(", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "int", "pc_len", "=", "AVR_2_BYTE_PC", "?", "2", ":", "3", ";", "int", "addend", "=", "INTVAL", "(", "op", "[", "0", "]", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "addend", "<", "0", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_print_asm_name", ")", "avr_asm_len", "(", "ASM_COMMENT_START", "\"SP -= %n0\"", ",", "op", ",", "plen", ",", "0", ")", ";", "while", "(", "addend", "<=", "-", "pc_len", ")", "{", "addend", "+=", "pc_len", ";", "avr_asm_len", "(", "\"rcall .\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "while", "(", "addend", "++", "<", "0", ")", "avr_asm_len", "(", "\"push __zero_reg__\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "addend", ">", "0", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_print_asm_name", ")", "avr_asm_len", "(", "ASM_COMMENT_START", "\"SP += %0\"", ",", "op", ",", "plen", ",", "0", ")", ";", "while", "(", "addend", "--", ">", "0", ")", "avr_asm_len", "(", "\"pop __tmp_reg__\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "PLEN", "==", "NULL", ":", "Output", "code", "to", "add", "CONST_INT", "OP", "[", "0", "]", "to", "SP", ".", "PLEN", "!", "=", "NULL", ":", "Set", "*", "PLEN", "to", "the", "length", "of", "that", "sequence", ".", "Return", "``", "''", "." ]

[ "avr", "2", "3", "0", "0", "0", "\"SP -= %n0\"", "0", "\"rcall .\"", "1", "0", "\"push __zero_reg__\"", "1", "0", "\"SP += %0\"", "0", "0", "\"pop __tmp_reg__\"", "1", "\"\"" ]

[]

[ "<s>", "static", "void", "rs6000_print_options_internal", "(", "FILE", "*", "file", ",", "int", "indent", ",", "const", "char", "*", "string", ",", "HOST_WIDE_INT", "flags", ",", "const", "char", "*", "prefix", ",", "const", "struct", "rs6000_opt_mask", "*", "opts", ",", "size_t", "num_elements", ")", "{", "size_t", "i", ";", "size_t", "start_column", "=", "0", ";", "size_t", "cur_column", ";", "size_t", "max_column", "=", "120", ";", "size_t", "prefix_len", "=", "strlen", "(", "prefix", ")", ";", "size_t", "comma_len", "=", "0", ";", "const", "char", "*", "comma", "=", "\"\"", ";", "if", "(", "indent", ")", "start_column", "+=", "fprintf", "(", "file", ",", "\"%*s\"", ",", "indent", ",", "\"\"", ")", ";", "if", "(", "!", "flags", ")", "{", "fprintf", "(", "stderr", ",", "DEBUG_FMT_S", ",", "string", ",", "\"<none>\"", ")", ";", "return", ";", "}", "start_column", "+=", "fprintf", "(", "stderr", ",", "DEBUG_FMT_WX", ",", "string", ",", "flags", ")", ";", "cur_column", "=", "start_column", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num_elements", ";", "i", "++", ")", "{", "bool", "invert", "=", "opts", "[", "i", "]", ".", "invert", ";", "const", "char", "*", "name", "=", "opts", "[", "i", "]", ".", "name", ";", "const", "char", "*", "no_str", "=", "\"\"", ";", "HOST_WIDE_INT", "mask", "=", "opts", "[", "i", "]", ".", "mask", ";", "size_t", "len", "=", "comma_len", "+", "prefix_len", "+", "strlen", "(", "name", ")", ";", "if", "(", "!", "invert", ")", "{", "if", "(", "(", "flags", "&", "mask", ")", "==", "0", ")", "{", "no_str", "=", "\"no-\"", ";", "len", "+=", "sizeof", "(", "\"no-\"", ")", "-", "1", ";", "}", "flags", "&=", "~", "mask", ";", "}", "else", "{", "if", "(", "(", "flags", "&", "mask", ")", "!=", "0", ")", "{", "no_str", "=", "\"no-\"", ";", "len", "+=", "sizeof", "(", "\"no-\"", ")", "-", "1", ";", "}", "flags", "|=", "mask", ";", "}", "cur_column", "+=", "len", ";", "if", "(", "cur_column", ">", "max_column", ")", "{", "fprintf", "(", "stderr", ",", "\", \\\\\\n%*s\"", ",", "(", "int", ")", "start_column", ",", "\"\"", ")", ";", "cur_column", "=", "start_column", "+", "len", ";", "comma", "=", "\"\"", ";", "}", "fprintf", "(", "file", ",", "\"%s%s%s%s\"", ",", "comma", ",", "prefix", ",", "no_str", ",", "name", ")", ";", "comma", "=", "\", \"", ";", "comma_len", "=", "sizeof", "(", "\", \"", ")", "-", "1", ";", "}", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "}", "</s>" ]

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

[ "rs6000", "0", "120", "0", "\"\"", "\"%*s\"", "\"\"", "\"<none>\"", "0", "\"\"", "0", "\"no-\"", "\"no-\"", "1", "0", "\"no-\"", "\"no-\"", "1", "\", \\\\\\n%*s\"", "\"\"", "\"\"", "\"%s%s%s%s\"", "\", \"", "\", \"", "1", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "h8300_push_pop", "(", "int", "regno", ",", "int", "nregs", ",", "int", "pop_p", ",", "int", "return_p", ")", "{", "int", "i", ",", "j", ";", "rtvec", "vec", ";", "rtx", "sp", ",", "offset", ";", "if", "(", "!", "return_p", "&&", "nregs", "==", "1", ")", "{", "if", "(", "pop_p", ")", "pop", "(", "regno", ")", ";", "else", "push", "(", "regno", ")", ";", "return", ";", "}", "vec", "=", "rtvec_alloc", "(", "(", "return_p", "!=", "0", ")", "+", "nregs", "+", "1", ")", ";", "sp", "=", "stack_pointer_rtx", ";", "i", "=", "0", ";", "if", "(", "return_p", ")", "{", "RTVEC_ELT", "(", "vec", ",", "i", ")", "=", "gen_rtx_RETURN", "(", "VOIDmode", ")", ";", "i", "++", ";", "}", "for", "(", "j", "=", "0", ";", "j", "<", "nregs", ";", "j", "++", ")", "{", "rtx", "lhs", ",", "rhs", ";", "if", "(", "pop_p", ")", "{", "lhs", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "j", ")", ";", "rhs", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "sp", ",", "(", "nregs", "-", "j", "-", "1", ")", "*", "4", ")", ")", ";", "}", "else", "{", "lhs", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "sp", ",", "(", "j", "+", "1", ")", "*", "-", "4", ")", ")", ";", "rhs", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "j", ")", ";", "}", "RTVEC_ELT", "(", "vec", ",", "i", "+", "j", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "lhs", ",", "rhs", ")", ";", "}", "offset", "=", "GEN_INT", "(", "(", "pop_p", "?", "nregs", ":", "-", "nregs", ")", "*", "4", ")", ";", "RTVEC_ELT", "(", "vec", ",", "i", "+", "j", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "sp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sp", ",", "offset", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "to", "push", "or", "pop", "NREGS", "consecutive", "registers", "starting", "at", "register", "REGNO", ".", "POP_P", "selects", "a", "pop", "rather", "than", "a", "push", "and", "RETURN_P", "is", "true", "if", "the", "instruction", "should", "return", ".", "It", "must", "be", "possible", "to", "do", "the", "requested", "operation", "in", "a", "single", "instruction", ".", "If", "NREGS", "==", "1", "&", "&", "!", "RETURN_P", ",", "use", "a", "normal", "push", "or", "pop", "insn", ".", "Otherwise", "emit", "a", "parallel", "of", "the", "form", ":", "(", "parallel", "[", "(", "return", ")", ";", ";", "if", "RETURN_P", "(", "save", "or", "restore", "REGNO", ")", "(", "save", "or", "restore", "REGNO", "+", "1", ")", "...", "(", "save", "or", "restore", "REGNO", "+", "NREGS", "-", "1", ")", "(", "set", "sp", "(", "plus", "sp", "(", "const_int", "adjust", ")", ")", ")", "]" ]

[ "h8300", "1", "0", "1", "0", "0", "1", "4", "1", "4", "4" ]

[]

[ "<s>", "static", "bool", "anticipatable_occurrence_p", "(", "const", "bb_info", "*", "bb", ",", "const", "vector_insn_info", "dem", ")", "{", "insn_info", "*", "insn", "=", "dem", ".", "get_insn", "(", ")", ";", "if", "(", "dem", ".", "has_avl_reg", "(", ")", ")", "{", "if", "(", "!", "vlmax_avl_p", "(", "dem", ".", "get_avl", "(", ")", ")", ")", "{", "set_info", "*", "set", "=", "dem", ".", "get_avl_source", "(", ")", ";", "if", "(", "!", "set", ")", "return", "false", ";", "if", "(", "real_insn_and_same_bb_p", "(", "set", "->", "insn", "(", ")", ",", "bb", ")", "&&", "before_p", "(", "set", "->", "insn", "(", ")", ",", "insn", ")", ")", "return", "false", ";", "}", "}", "if", "(", "vsetvl_insn_p", "(", "insn", "->", "rtl", "(", ")", ")", ")", "{", "rtx", "dest", "=", "get_vl", "(", "insn", "->", "rtl", "(", ")", ")", ";", "for", "(", "insn_info", "*", "i", "=", "insn", "->", "prev_nondebug_insn", "(", ")", ";", "real_insn_and_same_bb_p", "(", "i", ",", "bb", ")", ";", "i", "=", "i", "->", "prev_nondebug_insn", "(", ")", ")", "{", "if", "(", "find_access", "(", "i", "->", "uses", "(", ")", ",", "REGNO", "(", "dest", ")", ")", ")", "return", "false", ";", "if", "(", "find_access", "(", "i", "->", "defs", "(", ")", ",", "REGNO", "(", "dest", ")", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "An", "``", "anticipatable", "occurrence", "''", "is", "one", "that", "is", "the", "first", "occurrence", "in", "the", "basic", "block", ",", "the", "operands", "are", "not", "modified", "in", "the", "basic", "block", "prior", "to", "the", "occurrence", "and", "the", "output", "is", "not", "used", "between", "the", "start", "of", "the", "block", "and", "the", "occurrence", ".", "For", "VSETVL", "instruction", ",", "we", "have", "these", "following", "formats", ":", "1.", "vsetvl", "zero", ",", "rs1", ".", "2.", "vsetvl", "zero", ",", "imm", ".", "3.", "vsetvl", "rd", ",", "rs1", ".", "So", "base", "on", "these", "circumstances", ",", "a", "DEM", "is", "considered", "as", "a", "local", "anticipatable", "occurrence", "should", "satisfy", "these", "following", "conditions", ":", "1", ")", ".", "rs1", "(", "avl", ")", "are", "not", "modified", "in", "the", "basic", "block", "prior", "to", "the", "VSETVL", ".", "2", ")", ".", "rd", "(", "vl", ")", "are", "not", "modified", "in", "the", "basic", "block", "prior", "to", "the", "VSETVL", ".", "3", ")", ".", "rd", "(", "vl", ")", "is", "not", "used", "between", "the", "start", "of", "the", "block", "and", "the", "occurrence", ".", "Note", ":", "We", "do", "n't", "need", "to", "check", "VL/VTYPE", "here", "since", "DEM", "is", "UNKNOWN", "if", "VL/VTYPE", "is", "modified", "prior", "to", "the", "occurrence", ".", "This", "case", "is", "already", "considered", "as", "a", "non-local", "anticipatable", "occurrence", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "x86_extended_QIreg_mentioned_p", "(", "rtx_insn", "*", "insn", ")", "{", "int", "i", ";", "extract_insn_cached", "(", "insn", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "if", "(", "GENERAL_REG_P", "(", "recog_data", ".", "operand", "[", "i", "]", ")", "&&", "!", "QI_REGNO_P", "(", "REGNO", "(", "recog_data", ".", "operand", "[", "i", "]", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "nonzero", "when", "QImode", "register", "that", "must", "be", "represented", "via", "REX", "prefix", "is", "used", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "PatmosSinglePathInfo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "Root", ")", "{", "delete", "Root", ";", "Root", "=", "NULL", ";", "}", "std", "::", "string", "curfunc", "=", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", ";", "if", "(", "isConverting", "(", "MF", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Analyze '\"", "<<", "curfunc", "<<", "\"'\\n\"", ")", ";", "analyzeFunction", "(", "MF", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"[Single-Path] Analyze '\"", "\"'\\n\"" ]

[]

[ "<s>", "static", "void", "aarch64_add_cfa_expression", "(", "rtx_insn", "*", "insn", ",", "unsigned", "int", "reg", ",", "rtx", "base", ",", "poly_int64", "offset", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "regno_reg_rtx", "[", "reg", "]", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "REG_CFA_EXPRESSION", "note", "to", "INSN", "to", "say", "that", "register", "REG", "is", "saved", "at", "BASE", "+", "OFFSET", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlign", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "16" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "unsigned", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "ARM", "::", "LR", ",", "ARM", "::", "R11", ",", "ARM", "::", "R10", ",", "ARM", "::", "R9", ",", "ARM", "::", "R8", ",", "ARM", "::", "R7", ",", "ARM", "::", "R6", ",", "ARM", "::", "R5", ",", "ARM", "::", "R4", ",", "ARM", "::", "D15", ",", "ARM", "::", "D14", ",", "ARM", "::", "D13", ",", "ARM", "::", "D12", ",", "ARM", "::", "D11", ",", "ARM", "::", "D10", ",", "ARM", "::", "D9", ",", "ARM", "::", "D8", ",", "0", "}", ";", "static", "const", "unsigned", "DarwinCalleeSavedRegs", "[", "]", "=", "{", "ARM", "::", "LR", ",", "ARM", "::", "R7", ",", "ARM", "::", "R6", ",", "ARM", "::", "R5", ",", "ARM", "::", "R4", ",", "ARM", "::", "R11", ",", "ARM", "::", "R10", ",", "ARM", "::", "R8", ",", "ARM", "::", "D15", ",", "ARM", "::", "D14", ",", "ARM", "::", "D13", ",", "ARM", "::", "D12", ",", "ARM", "::", "D11", ",", "ARM", "::", "D10", ",", "ARM", "::", "D9", ",", "ARM", "::", "D8", ",", "0", "}", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "DarwinCalleeSavedRegs", ":", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LR", "ARM::R11", "ARM::R10", "ARM::R9", "ARM::R8", "ARM::R7", "ARM::R6", "ARM::R5", "ARM::R4", "ARM::D15", "ARM::D14", "ARM::D13", "ARM::D12", "ARM::D11", "ARM::D10", "ARM::D9", "ARM::D8", "0", "ARM::LR", "ARM::R7", "ARM::R6", "ARM::R5", "ARM::R4", "ARM::R11", "ARM::R10", "ARM::R8", "ARM::D15", "ARM::D14", "ARM::D13", "ARM::D12", "ARM::D11", "ARM::D10", "ARM::D9", "ARM::D8", "0" ]

[]

[ "<s>", "enum", "avms_arg_type", "alpha_arg_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FF", ":", "FS", ";", "case", "E_DFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FD", ":", "FT", ";", "default", ":", "return", "I64", ";", "}", "}", "</s>" ]

[ "Return", "the", "VMS", "argument", "type", "corresponding", "to", "MODE", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "aarch64_expand_sve_vec_cmp_float", "(", "rtx", "target", ",", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "bool", "can_invert_p", ")", "{", "machine_mode", "pred_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "data_mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "ptrue", "=", "aarch64_ptrue_reg", "(", "pred_mode", ")", ";", "switch", "(", "code", ")", "{", "case", "UNORDERED", ":", "op1", "=", "force_reg", "(", "data_mode", ",", "op1", ")", ";", "case", "LT", ":", "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "case", "EQ", ":", "case", "NE", ":", "{", "aarch64_emit_sve_fp_cond", "(", "target", ",", "code", ",", "ptrue", ",", "true", ",", "op0", ",", "op1", ")", ";", "return", "false", ";", "}", "case", "LTGT", ":", "aarch64_emit_sve_or_fp_conds", "(", "target", ",", "LT", ",", "GT", ",", "ptrue", ",", "true", ",", "op0", ",", "op1", ")", ";", "return", "false", ";", "case", "UNEQ", ":", "if", "(", "!", "flag_trapping_math", ")", "{", "op1", "=", "force_reg", "(", "data_mode", ",", "op1", ")", ";", "aarch64_emit_sve_or_fp_conds", "(", "target", ",", "UNORDERED", ",", "EQ", ",", "ptrue", ",", "true", ",", "op0", ",", "op1", ")", ";", "return", "false", ";", "}", "case", "UNLT", ":", "case", "UNLE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "if", "(", "flag_trapping_math", ")", "{", "rtx", "ordered", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "op1", "=", "force_reg", "(", "data_mode", ",", "op1", ")", ";", "aarch64_emit_sve_invert_fp_cond", "(", "ordered", ",", "UNORDERED", ",", "ptrue", ",", "true", ",", "op0", ",", "op1", ")", ";", "if", "(", "code", "==", "UNEQ", ")", "code", "=", "NE", ";", "else", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "if", "(", "can_invert_p", ")", "{", "aarch64_emit_sve_fp_cond", "(", "target", ",", "code", ",", "ordered", ",", "false", ",", "op0", ",", "op1", ")", ";", "return", "true", ";", "}", "aarch64_emit_sve_invert_fp_cond", "(", "target", ",", "code", ",", "ordered", ",", "false", ",", "op0", ",", "op1", ")", ";", "return", "false", ";", "}", "break", ";", "case", "ORDERED", ":", "op1", "=", "force_reg", "(", "data_mode", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "if", "(", "can_invert_p", ")", "{", "aarch64_emit_sve_fp_cond", "(", "target", ",", "code", ",", "ptrue", ",", "true", ",", "op0", ",", "op1", ")", ";", "return", "true", ";", "}", "aarch64_emit_sve_invert_fp_cond", "(", "target", ",", "code", ",", "ptrue", ",", "true", ",", "op0", ",", "op1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Expand", "an", "SVE", "floating-point", "comparison", ":", "TARGET", "=", "CODE", "(", "OP0", ",", "OP1", ")", "If", "CAN_INVERT_P", "is", "true", ",", "the", "caller", "can", "also", "handle", "inverted", "results", ";", "return", "true", "if", "the", "result", "is", "in", "fact", "inverted", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "m32c_expand_setmemhi", "(", "rtx", "*", "operands", ")", "{", "rtx", "desta", ",", "count", ",", "val", ";", "rtx", "desto", ",", "counto", ";", "desta", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "count", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "desto", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "counto", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "if", "(", "GET_CODE", "(", "desta", ")", "!=", "REG", "||", "REGNO", "(", "desta", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "desta", "=", "copy_to_mode_reg", "(", "Pmode", ",", "desta", ")", ";", "if", "(", "GET_CODE", "(", "count", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "val", ")", "==", "CONST_INT", "&&", "!", "(", "INTVAL", "(", "count", ")", "&", "1", ")", "&&", "(", "INTVAL", "(", "count", ")", ">", "1", ")", "&&", "(", "INTVAL", "(", "val", ")", "<=", "7", "&&", "INTVAL", "(", "val", ")", ">=", "-", "8", ")", ")", "{", "unsigned", "v", "=", "INTVAL", "(", "val", ")", "&", "0xff", ";", "v", "=", "v", "|", "(", "v", "<<", "8", ")", ";", "count", "=", "copy_to_mode_reg", "(", "HImode", ",", "GEN_INT", "(", "INTVAL", "(", "count", ")", "/", "2", ")", ")", ";", "val", "=", "copy_to_mode_reg", "(", "HImode", ",", "GEN_INT", "(", "v", ")", ")", ";", "if", "(", "TARGET_A16", ")", "emit_insn", "(", "gen_setmemhi_whi_op", "(", "desto", ",", "counto", ",", "val", ",", "desta", ",", "count", ")", ")", ";", "else", "emit_insn", "(", "gen_setmemhi_wpsi_op", "(", "desto", ",", "counto", ",", "val", ",", "desta", ",", "count", ")", ")", ";", "return", "1", ";", "}", "if", "(", "GET_CODE", "(", "val", ")", "!=", "REG", "||", "REGNO", "(", "val", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "val", "=", "copy_to_mode_reg", "(", "QImode", ",", "val", ")", ";", "if", "(", "GET_CODE", "(", "count", ")", "!=", "REG", "||", "REGNO", "(", "count", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "count", "=", "copy_to_mode_reg", "(", "HImode", ",", "count", ")", ";", "if", "(", "TARGET_A16", ")", "emit_insn", "(", "gen_setmemhi_bhi_op", "(", "desto", ",", "counto", ",", "val", ",", "desta", ",", "count", ")", ")", ";", "else", "emit_insn", "(", "gen_setmemhi_bpsi_op", "(", "desto", ",", "counto", ",", "val", ",", "desta", ",", "count", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "This", "is", "a", "memset", "(", ")", "opcode", ".", "All", "operands", "are", "implied", ",", "so", "we", "need", "to", "arrange", "for", "them", "to", "be", "in", "the", "right", "registers", ".", "The", "opcode", "wants", "addresses", ",", "not", "[", "mem", "]", "syntax", ".", "$", "0", "is", "the", "destination", "(", "MEM", ":", "BLK", ")", ",", "$", "1", "the", "count", "(", "HI", ")", ",", "and", "$", "2", "the", "value", "(", "QI", ")", "." ]

[ "m32c", "0", "0", "1", "2", "1", "1", "7", "8", "0xff", "8", "2", "1", "1" ]

[]