Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "s390_function_arg_integer", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "size", ">", "8", ")", "return", "false", ";", "if", "(", "!", "type", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "(", "TARGET_SOFT_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "OFFSET_TYPE", "||", "(", "TARGET_SOFT_FLOAT", "&&", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", ")", ")", "return", "true", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "exact_log2", "(", "size", ")", ">=", "0", "&&", "!", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "function", "argument", "of", "type", "TYPE", "and", "mode", "MODE", "is", "to", "be", "passed", "in", "an", "integer", "register", ",", "or", "a", "pair", "of", "integer", "registers", ",", "if", "available", "." ]

[ "s390", "8", "0" ]

[]

[ "<s>", "unsigned", "assignCustomValue", "(", "const", "ARMCallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ")", "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\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "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", "\"Unsupported type\"", "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", "R600InstrInfo", "::", "isVector", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "VECTOR", ";", "}", "</s>" ]

[ "Vector", "instructions", "are", "instructions", "that", "must", "fill", "all", "instruction", "slots", "within", "an", "instruction", "group", "." ]

[ "R600", "R600_InstFlag::VECTOR" ]

[]

[ "<s>", "InstructionCost", "ARMTargetLowering", "::", "getScalingFactorCost", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "isLegalAddressingMode", "(", "DL", ",", "AM", ",", "Ty", ",", "AS", ")", ")", "{", "if", "(", "Subtarget", "->", "hasFPAO", "(", ")", ")", "return", "AM", ".", "Scale", "<", "0", "?", "1", ":", "0", ";", "return", "0", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "scaling", "factor", "used", "in", "the", "addressing", "mode", "represented", "by", "AM", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_emit_stack_tie", "(", "void", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "rs6000_sr_alias_set", ")", ";", "emit_insn", "(", "gen_stack_tie", "(", "mem", ")", ")", ";", "}", "</s>" ]

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

[ "rs6000" ]

[]

[ "<s>", "void", "AnalyzeFormalArguments", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "CCAssignFn", "Fn", ")", "{", "PreAnalyzeFormalArgumentsForF128", "(", "Ins", ")", ";", "CCState", "::", "AnalyzeFormalArguments", "(", "Ins", ",", "Fn", ")", ";", "OriginalArgWasFloat", ".", "clear", "(", ")", ";", "OriginalArgWasF128", ".", "clear", "(", ")", ";", "OriginalArgWasFloatVector", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AnalyzeFormalArguments", "-", "Analyze", "an", "array", "of", "argument", "values", ",", "incorporating", "info", "about", "the", "formals", "into", "this", "state", "." ]

[ "Mips", "ISD::InputArg" ]

[]

[ "<s>", "bool", "ix86_match_ccmode", "(", "rtx", "insn", ",", "machine_mode", "req_mode", ")", "{", "rtx", "set", ";", "machine_mode", "set_mode", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "PARALLEL", ")", "set", "=", "XVECEXP", "(", "set", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", ")", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "E_CCNOmode", ":", "if", "(", "req_mode", "!=", "CCNOmode", "&&", "(", "req_mode", "!=", "CCmode", "||", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "!=", "const0_rtx", ")", ")", "return", "false", ";", "break", ";", "case", "E_CCmode", ":", "if", "(", "req_mode", "==", "CCGCmode", ")", "return", "false", ";", "case", "E_CCGCmode", ":", "if", "(", "req_mode", "==", "CCGOCmode", "||", "req_mode", "==", "CCNOmode", ")", "return", "false", ";", "case", "E_CCGOCmode", ":", "if", "(", "req_mode", "==", "CCZmode", ")", "return", "false", ";", "case", "E_CCZmode", ":", "break", ";", "case", "E_CCGZmode", ":", "case", "E_CCAmode", ":", "case", "E_CCCmode", ":", "case", "E_CCOmode", ":", "case", "E_CCPmode", ":", "case", "E_CCSmode", ":", "if", "(", "set_mode", "!=", "req_mode", ")", "return", "false", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ";", "}", "</s>" ]

[ "Return", "TRUE", "or", "FALSE", "depending", "on", "whether", "the", "first", "SET", "in", "INSN", "has", "source", "and", "destination", "with", "matching", "CC", "modes", ",", "and", "that", "the", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "bool", "MemSelOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PIC16" ]

[]

[ "<s>", "unsigned", "getOpSize", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "return", "getOpRegClass", "(", "MI", ",", "OpNo", ")", "->", "getSize", "(", ")", ";", "}", "</s>" ]

[ "This", "form", "should", "usually", "be", "preferred", "since", "it", "handles", "operands", "with", "unknown", "register", "classes", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "HST", "=", "static_cast", "<", "const", "HexagonSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "MachineBasicBlock", "*", "PrologB", "=", "&", "MF", ".", "front", "(", ")", ",", "*", "EpilogB", "=", "nullptr", ";", "if", "(", "EnableShrinkWrapping", ")", "findShrunkPrologEpilog", "(", "MF", ",", "PrologB", ",", "EpilogB", ")", ";", "insertCSRSpillsInBlock", "(", "*", "PrologB", ",", "CSI", ",", "HRI", ")", ";", "insertPrologueInBlock", "(", "*", "PrologB", ")", ";", "if", "(", "EpilogB", ")", "{", "insertCSRRestoresInBlock", "(", "*", "EpilogB", ",", "CSI", ",", "HRI", ")", ";", "insertEpilogueInBlock", "(", "*", "EpilogB", ")", ";", "}", "else", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "isReturnBlock", "(", ")", ")", "insertCSRRestoresInBlock", "(", "B", ",", "CSI", ",", "HRI", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "isReturnBlock", "(", ")", ")", "insertEpilogueInBlock", "(", "B", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"Shrink-wrapping not yet supported\"" ]

[]

[ "<s>", "enum", "m32r_function_type", "m32r_compute_function_type", "(", "tree", "decl", ")", "{", "static", "enum", "m32r_function_type", "fn_type", "=", "M32R_FUNCTION_UNKNOWN", ";", "static", "tree", "last_fn", "=", "NULL_TREE", ";", "if", "(", "decl", "==", "NULL_TREE", ")", "{", "fn_type", "=", "M32R_FUNCTION_UNKNOWN", ";", "last_fn", "=", "NULL_TREE", ";", "return", "fn_type", ";", "}", "if", "(", "decl", "==", "last_fn", "&&", "fn_type", "!=", "M32R_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", "!=", "NULL_TREE", "?", "M32R_FUNCTION_INTERRUPT", ":", "M32R_FUNCTION_NORMAL", ")", ";", "last_fn", "=", "decl", ";", "return", "fn_type", ";", "}", "</s>" ]

[ "Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "." ]

[ "m32r", "\"interrupt\"" ]

[]

[ "<s>", "static", "void", "swap_reorder", "(", "rtx", "*", "a", ",", "int", "n", ")", "{", "rtx", "insn", "=", "a", "[", "n", "-", "1", "]", ";", "int", "i", "=", "n", "-", "2", ";", "while", "(", "i", ">=", "0", "&&", "rank_for_reorder", "(", "a", "+", "i", ",", "&", "insn", ")", ">=", "0", ")", "{", "a", "[", "i", "+", "1", "]", "=", "a", "[", "i", "]", ";", "i", "-=", "1", ";", "}", "a", "[", "i", "+", "1", "]", "=", "insn", ";", "}", "</s>" ]

[ "Resort", "the", "array", "A", "in", "which", "only", "element", "at", "index", "N", "may", "be", "out", "of", "order", "." ]

[ "sh", "1", "2", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "void", "GCNIterativeScheduler", "::", "finalizeSchedule", "(", ")", "{", "if", "(", "Regions", ".", "empty", "(", ")", ")", "return", ";", "switch", "(", "Strategy", ")", "{", "case", "SCHEDULE_MINREGONLY", ":", "scheduleMinReg", "(", ")", ";", "break", ";", "case", "SCHEDULE_MINREGFORCED", ":", "scheduleMinReg", "(", "true", ")", ";", "break", ";", "case", "SCHEDULE_LEGACYMAXOCCUPANCY", ":", "scheduleLegacyMaxOccupancy", "(", ")", ";", "break", ";", "case", "SCHEDULE_ILP", ":", "scheduleILP", "(", "false", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "After", "the", "schedule", "has", "been", "formed", ",", "call", "this", "function", "to", "combine", "the", "instructions", "from", "the", "different", "stages/cycles", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "X86RegisterInfo", "*", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getGPRsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", "&&", "CS", "!=", "X86", "::", "RIP", "&&", "CS", "!=", "X86", "::", "RSP", "&&", "CS", "!=", "X86", "::", "ESP", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "X86", "0", "0", "0", "X86::RET", "X86::RETL", "X86::RETQ", "X86::RETIL", "X86::RETIQ", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "X86::RIP", "X86::RSP", "X86::ESP", "0" ]

[]

[ "<s>", "void", "function_expander", "::", "add_address_operand", "(", "rtx", "x", ")", "{", "m_ops", ".", "safe_grow", "(", "m_ops", ".", "length", "(", ")", "+", "1", ")", ";", "create_address_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "x", ")", ";", "}", "</s>" ]

[ "Add", "an", "address", "operand", "with", "value", "X", ".", "The", "static", "operand", "data", "says", "what", "mode", "and", "form", "the", "address", "must", "have", "." ]

[ "aarch64", "1" ]

[]

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

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

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

[]

[ "<s>", "static", "int", "uses_TOC", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "int", "ret", "=", "1", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "sub", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "sub", ")", "==", "USE", ")", "{", "sub", "=", "XEXP", "(", "sub", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "sub", ")", "==", "UNSPEC", "&&", "XINT", "(", "sub", ",", "1", ")", "==", "UNSPEC_TOC", ")", "return", "ret", ";", "}", "}", "}", "else", "if", "(", "crtl", "->", "has_bb_partition", "&&", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_SWITCH_TEXT_SECTIONS", ")", "ret", "=", "2", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "This", "retuns", "nonzero", "if", "the", "current", "function", "uses", "the", "TOC", ".", "This", "is", "determined", "by", "the", "presence", "of", "(", "unspec", "...", "7", ")", ",", "which", "is", "generated", "by", "the", "various", "load_toc_", "*", "patterns", "." ]

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isLdStPairSuppressed", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "any_of", "(", "MI", ".", "memoperands", "(", ")", ",", "[", "]", "(", "MachineMemOperand", "*", "MMO", ")", "{", "return", "MMO", "->", "getFlags", "(", ")", "&", "MOSuppressPair", ";", "}", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "is", "hinted", "to", "be", "unprofitable", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineInstr", "*", "Return", "=", "MIRBuilder", ".", "buildInstr", "(", "AArch64", "::", "RET_ReallyLR", ")", ";", "assert", "(", "Return", "&&", "\"Unable to build a return instruction?!\"", ")", ";", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "if", "(", "VReg", ")", "{", "assert", "(", "Val", "->", "getType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "\"Type not supported yet\"", ")", ";", "unsigned", "Size", "=", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "assert", "(", "(", "Size", "==", "64", "||", "Size", "==", "32", ")", "&&", "\"Size not supported yet\"", ")", ";", "unsigned", "ResReg", "=", "(", "Size", "==", "32", ")", "?", "AArch64", "::", "W0", ":", "AArch64", "::", "X0", ";", "MIRBuilder", ".", "setInstr", "(", "*", "Return", ",", "true", ")", ";", "MachineInstr", "*", "Copy", "=", "MIRBuilder", ".", "buildInstr", "(", "TargetOpcode", "::", "COPY", ",", "ResReg", ",", "VReg", ")", ";", "(", "void", ")", "Copy", ";", "assert", "(", "Copy", "->", "getNextNode", "(", ")", "==", "Return", "&&", "\"The insertion did not happen where we expected\"", ")", ";", "MachineInstrBuilder", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Return", ")", ".", "addReg", "(", "ResReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::RET_ReallyLR", "\"Unable to build a return instruction?!\"", "\"Return value without a vreg\"", "\"Type not supported yet\"", "64", "32", "\"Size not supported yet\"", "32", "AArch64::W0", "AArch64::X0", "\"The insertion did not happen where we expected\"" ]

[]

[ "<s>", "const", "LanaiTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "Lanai", "Lanai" ]

[]

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

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

[ "AArch64", "AArch64", "AArch64::CCRRegClass", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "ARMBaseTargetMachine", "&", "TM", ",", "bool", "IsLittle", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "ARMProcClass", "(", "None", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeFrameLowering", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SIMachineFunctionInfo", "::", "removeDeadFrameIndices", "(", "MachineFrameInfo", "&", "MFI", ")", "{", "for", "(", "auto", "&", "R", ":", "make_early_inc_range", "(", "SGPRToVGPRSpills", ")", ")", "{", "if", "(", "R", ".", "first", "!=", "FramePointerSaveIndex", "&&", "R", ".", "first", "!=", "BasePointerSaveIndex", ")", "{", "MFI", ".", "RemoveStackObject", "(", "R", ".", "first", ")", ";", "SGPRToVGPRSpills", ".", "erase", "(", "R", ".", "first", ")", ";", "}", "}", "for", "(", "int", "i", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ",", "e", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "i", "!=", "FramePointerSaveIndex", "&&", "i", "!=", "BasePointerSaveIndex", ")", "MFI", ".", "setStackID", "(", "i", ",", "TargetStackID", "::", "Default", ")", ";", "for", "(", "auto", "&", "R", ":", "VGPRToAGPRSpills", ")", "{", "if", "(", "R", ".", "second", ".", "FullyAllocated", ")", "MFI", ".", "RemoveStackObject", "(", "R", ".", "first", ")", ";", "}", "}", "</s>" ]

[ "If", "ResetSGPRSpillStackIDs", "is", "true", ",", "reset", "the", "stack", "ID", "from", "sgpr-spill", "to", "the", "default", "stack", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "static", "enum", "immediate_class", "classify_immediate", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "val", ";", "unsigned", "char", "arr", "[", "16", "]", ";", "int", "i", ",", "j", ",", "repeated", ",", "fsmbi", ",", "repeat", ";", "gcc_assert", "(", "CONSTANT_P", "(", "op", ")", ")", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "!", "flag_pic", "&&", "mode", "==", "V4SImode", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", "&&", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", "!=", "CONST_DOUBLE", ")", "op", "=", "unwrap_const_vec_duplicate", "(", "op", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "TARGET_LARGE_MEM", "?", "IC_IL2s", ":", "IC_IL1s", ";", "case", "CONST", ":", "if", "(", "!", "TARGET_LARGE_MEM", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", ")", "{", "rtx", "sym", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "rtx", "cst", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "cst", ")", "==", "CONST_INT", "&&", "satisfies_constraint_K", "(", "cst", ")", ")", "return", "IC_IL1s", ";", "}", "return", "IC_IL2s", ";", "case", "HIGH", ":", "return", "IC_IL1s", ";", "case", "CONST_VECTOR", ":", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_NUNITS", "(", "mode", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ")", "!=", "CONST_DOUBLE", ")", "return", "IC_POOL", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "constant_to_array", "(", "mode", ",", "op", ",", "arr", ")", ";", "repeated", "=", "1", ";", "for", "(", "i", "=", "4", ";", "i", "<", "16", ";", "i", "+=", "4", ")", "for", "(", "j", "=", "0", ";", "j", "<", "4", ";", "j", "++", ")", "if", "(", "arr", "[", "j", "]", "!=", "arr", "[", "i", "+", "j", "]", ")", "repeated", "=", "0", ";", "if", "(", "repeated", ")", "{", "val", "=", "(", "arr", "[", "0", "]", "<<", "24", ")", "|", "(", "arr", "[", "1", "]", "<<", "16", ")", "|", "(", "arr", "[", "2", "]", "<<", "8", ")", "|", "arr", "[", "3", "]", ";", "val", "=", "trunc_int_for_mode", "(", "val", ",", "SImode", ")", ";", "if", "(", "which_immediate_load", "(", "val", ")", "!=", "SPU_NONE", ")", "return", "IC_IL1", ";", "}", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "2", ")", ";", "fsmbi", "=", "1", ";", "repeat", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", "&&", "fsmbi", ";", "i", "++", ")", "if", "(", "arr", "[", "i", "]", "!=", "0", "&&", "repeat", "==", "0", ")", "repeat", "=", "arr", "[", "i", "]", ";", "else", "if", "(", "arr", "[", "i", "]", "!=", "0", "&&", "arr", "[", "i", "]", "!=", "repeat", ")", "fsmbi", "=", "0", ";", "if", "(", "fsmbi", ")", "return", "repeat", "==", "0xff", "?", "IC_FSMBI", ":", "IC_FSMBI2", ";", "if", "(", "cpat_info", "(", "arr", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "0", ",", "0", ")", ")", "return", "IC_CPAT", ";", "if", "(", "repeated", ")", "return", "IC_IL2", ";", "return", "IC_POOL", ";", "default", ":", "break", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "OP", "is", "a", "CONSTANT_P", ".", "Determine", "what", "instructions", "can", "be", "used", "to", "load", "it", "into", "a", "register", ".", "MODE", "is", "only", "valid", "when", "OP", "is", "a", "CONST_INT", "." ]

[ "spu", "16", "0", "0", "0", "0", "0", "0", "1", "0", "1", "4", "16", "4", "0", "4", "0", "0", "24", "1", "16", "2", "8", "3", "2", "1", "0", "0", "16", "0", "0", "0", "0", "0xff", "0", "0" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwin", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "if", "(", "!", "EnableRegisterScavenging", ")", "Reserved", ".", "set", "(", "PPC", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "}", "if", "(", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "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::R0", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::R2", "PPC", "PPC::R13", "PPC::R31", "PPC::R0", "PPC::X0", "PPC::X1", "PPC::X13", "PPC::X31", "PPC::R31" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "riscv_first_stack_step", "(", "struct", "riscv_frame_info", "*", "frame", ")", "{", "HOST_WIDE_INT", "min_first_step", "=", "frame", "->", "total_size", "-", "frame", "->", "fp_sp_offset", ";", "HOST_WIDE_INT", "max_first_step", "=", "IMM_REACH", "/", "2", "-", "STACK_BOUNDARY", "/", "8", ";", "if", "(", "SMALL_OPERAND", "(", "frame", "->", "total_size", ")", ")", "return", "frame", "->", "total_size", ";", "if", "(", "!", "SMALL_OPERAND", "(", "frame", "->", "total_size", "-", "max_first_step", ")", "&&", "frame", "->", "total_size", "%", "IMM_REACH", "<", "IMM_REACH", "/", "2", "&&", "frame", "->", "total_size", "%", "IMM_REACH", ">=", "min_first_step", ")", "return", "frame", "->", "total_size", "%", "IMM_REACH", ";", "gcc_assert", "(", "min_first_step", "<=", "max_first_step", ")", ";", "return", "max_first_step", ";", "}", "</s>" ]

[ "For", "stack", "frames", "that", "ca", "n't", "be", "allocated", "with", "a", "single", "ADDI", "instruction", ",", "compute", "the", "best", "value", "to", "initially", "allocate", ".", "It", "must", "at", "a", "minimum", "allocate", "enough", "space", "to", "spill", "the", "callee-saved", "registers", "." ]

[ "riscv", "2", "8", "2" ]

[]

[ "<s>", "void", "BTFTypeTypeTag", "::", "completeType", "(", "BTFDebug", "&", "BDebug", ")", "{", "if", "(", "IsCompleted", ")", "return", ";", "IsCompleted", "=", "true", ";", "BTFType", ".", "NameOff", "=", "BDebug", ".", "addString", "(", "Tag", ")", ";", "if", "(", "DTy", ")", "{", "const", "DIType", "*", "ResolvedType", "=", "DTy", "->", "getBaseType", "(", ")", ";", "if", "(", "!", "ResolvedType", ")", "BTFType", ".", "Type", "=", "0", ";", "else", "BTFType", ".", "Type", "=", "BDebug", ".", "getTypeId", "(", "ResolvedType", ")", ";", "}", "}", "</s>" ]

[ "Complete", "BTF", "type", "generation", "after", "all", "related", "DebugInfo", "types", "have", "been", "visited", "so", "their", "BTF", "type", "id", "'s", "are", "available", "for", "cross", "referece", "." ]

[ "BPF", "0" ]

[]

[ "<s>", "bool", "Thumb2ITBlockPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "restrictIT", "=", "STI", ".", "restrictIT", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "++", "MFI", ";", "Modified", "|=", "InsertITInstructions", "(", "MBB", ")", ";", "}", "if", "(", "Modified", ")", "AFI", "->", "setHasITBlocks", "(", "true", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "isInlineConstant", "(", "const", "APFloat", "&", "Imm", ")", "const", "{", "return", "isInlineConstant", "(", "Imm", ".", "bitcastToAPInt", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "c6x_expand_call", "(", "rtx", "retval", ",", "rtx", "address", ",", "bool", "sibcall", ")", "{", "rtx", "callee", "=", "XEXP", "(", "address", ",", "0", ")", ";", "rtx", "call_insn", ";", "if", "(", "!", "c6x_call_operand", "(", "callee", ",", "Pmode", ")", ")", "{", "callee", "=", "force_reg", "(", "Pmode", ",", "callee", ")", ";", "address", "=", "change_address", "(", "address", ",", "Pmode", ",", "callee", ")", ";", "}", "call_insn", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "address", ",", "const0_rtx", ")", ";", "if", "(", "sibcall", ")", "{", "call_insn", "=", "emit_call_insn", "(", "call_insn", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "call_insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "REG_B3", ")", ")", ";", "}", "else", "{", "if", "(", "retval", "==", "NULL_RTX", ")", "call_insn", "=", "emit_call_insn", "(", "call_insn", ")", ";", "else", "call_insn", "=", "emit_call_insn", "(", "gen_rtx_SET", "(", "GET_MODE", "(", "retval", ")", ",", "retval", ",", "call_insn", ")", ")", ";", "}", "if", "(", "flag_pic", ")", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "call_insn", ")", ",", "pic_offset_table_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "the", "sequence", "for", "a", "call", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AVR Frame Analyzer\"", ";", "}", "</s>" ]

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

[ "AVR", "\"AVR Frame Analyzer\"" ]

[]

[ "<s>", "DecodeStatus", "BPFDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "bool", "IsLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "uint64_t", "Insn", ",", "Hi", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint8_t", "InstClass", "=", "getInstClass", "(", "Insn", ")", ";", "if", "(", "(", "InstClass", "==", "BPF_LDX", "||", "InstClass", "==", "BPF_STX", ")", "&&", "getInstSize", "(", "Insn", ")", "!=", "BPF_DW", "&&", "getInstMode", "(", "Insn", ")", "==", "BPF_MEM", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "BPF", "::", "ALU32", "]", ")", "Result", "=", "decodeInstruction", "(", "DecoderTableBPFALU3264", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "else", "Result", "=", "decodeInstruction", "(", "DecoderTableBPF64", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "switch", "(", "Instr", ".", "getOpcode", "(", ")", ")", "{", "case", "BPF", "::", "LD_imm64", ":", "case", "BPF", "::", "LD_pseudo", ":", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "16", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Size", "=", "16", ";", "if", "(", "IsLittleEndian", ")", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "0", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "24", ")", ";", "else", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "0", ")", ";", "auto", "&", "Op", "=", "Instr", ".", "getOperand", "(", "1", ")", ";", "Op", ".", "setImm", "(", "Make_64", "(", "Hi", ",", "Op", ".", "getImm", "(", ")", ")", ")", ";", "break", ";", "}", "case", "BPF", "::", "LD_ABS_B", ":", "case", "BPF", "::", "LD_ABS_H", ":", "case", "BPF", "::", "LD_ABS_W", ":", "case", "BPF", "::", "LD_IND_B", ":", "case", "BPF", "::", "LD_IND_H", ":", "case", "BPF", "::", "LD_IND_W", ":", "{", "auto", "Op", "=", "Instr", ".", "getOperand", "(", "0", ")", ";", "Instr", ".", "clear", "(", ")", ";", "Instr", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "BPF", "::", "R6", ")", ")", ";", "Instr", ".", "addOperand", "(", "Op", ")", ";", "break", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF", "BPF", "BPF", "BPF", "BPF::ALU32", "BPF", "BPF", "BPF::LD_imm64", "BPF::LD_pseudo", "16", "0", "16", "12", "0", "13", "8", "14", "16", "15", "24", "12", "24", "13", "16", "14", "8", "15", "0", "1", "BPF::LD_ABS_B", "BPF::LD_ABS_H", "BPF::LD_ABS_W", "BPF::LD_IND_B", "BPF::LD_IND_H", "BPF::LD_IND_W", "0", "BPF::R6" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "m32c_function_arg_advance", "(", "cumulative_args_t", "ca_v", ",", "const", "function_arg_info", "&", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "if", "(", "ca", "->", "force_mem", ")", "ca", "->", "force_mem", "=", "0", ";", "else", "ca", "->", "parm_num", "++", ";", "}", "</s>" ]

[ "Implements", "FUNCTION_ARG_ADVANCE", ".", "force_mem", "is", "set", "for", "functions", "returning", "structures", ",", "so", "we", "always", "reset", "that", ".", "Otherwise", ",", "we", "only", "need", "to", "know", "the", "sequence", "number", "of", "the", "argument", "to", "know", "what", "to", "do", "with", "it", "." ]

[ "m32c", "0" ]

[]

[ "<s>", "static", "bool", "already_contains", "(", "rtx", "loc", ",", "rtx", "value", ")", "{", "unsigned", "char", "index", ";", "unsigned", "char", "val", ";", "if", "(", "(", "index", "=", "get_content_index", "(", "loc", ")", ")", "==", "NOT_KNOWN", ")", "return", "false", ";", "if", "(", "(", "val", "=", "get_content_index", "(", "value", ")", ")", "==", "NOT_KNOWN", ")", "return", "false", ";", "if", "(", "content_memory", "[", "index", "]", "!=", "val", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "loc", ")", "==", "HImode", ")", "return", "content_memory", "[", "index", "+", "1", "]", "==", "val", "+", "1", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "LOC", "already", "contains", "a", "copy", "of", "VALUE", "." ]

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

[]

[ "<s>", "static", "int", "s390_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "TARGET_Z10", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "FP_REGS", ")", ")", "return", "1", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", "&&", "reg_classes_intersect_p", "(", "from", ",", "FP_REGS", ")", ")", "return", "3", ";", "}", "if", "(", "(", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "FP_REGS", ")", ")", "||", "(", "reg_classes_intersect_p", "(", "from", ",", "FP_REGS", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", ")", "return", "10", ";", "if", "(", "reg_classes_intersect_p", "(", "from", ",", "CC_REGS", ")", "||", "reg_classes_intersect_p", "(", "to", ",", "CC_REGS", ")", ")", "return", "5", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", "." ]

[ "s390", "8", "1", "3", "10", "5", "1" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "MSP430::FPW", "MSP430::SPW", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]

[]

[ "<s>", "static", "int", "thumb_base_register_rtx_p", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ",", "int", "strict_p", ")", "{", "int", "regno", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "REG", ")", "return", "0", ";", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "strict_p", ")", "return", "THUMB_REGNO_MODE_OK_FOR_BASE_P", "(", "regno", ",", "mode", ")", ";", "return", "(", "regno", "<=", "LAST_LO_REGNUM", "||", "regno", ">", "LAST_VIRTUAL_REGISTER", "||", "regno", "==", "FRAME_POINTER_REGNUM", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "&&", "(", "regno", "==", "STACK_POINTER_REGNUM", "||", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "x", "==", "hard_frame_pointer_rtx", "||", "x", "==", "arg_pointer_rtx", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "valid", "as", "a", "Thumb", "state", "base", "register", "." ]

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

[]

[ "<s>", "Reloc", "::", "Model", "MipsSubtarget", "::", "getRelocationModel", "(", ")", "const", "{", "return", "TM", "->", "getRelocationModel", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "code", "generation", "relocation", "model", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "for", "(", "std", "::", "map", "<", "const", "char", "*", ",", "const", "Mips16HardFloatInfo", "::", "FuncSignature", "*", ">", "::", "const_iterator", "it", "=", "MipsFI", "->", "StubsNeeded", ".", "begin", "(", ")", ";", "it", "!=", "MipsFI", "->", "StubsNeeded", ".", "end", "(", ")", ";", "++", "it", ")", "{", "const", "char", "*", "Symbol", "=", "it", "->", "first", ";", "const", "Mips16HardFloatInfo", "::", "FuncSignature", "*", "Signature", "=", "it", "->", "second", ";", "if", "(", "StubsNeeded", ".", "find", "(", "Symbol", ")", "==", "StubsNeeded", ".", "end", "(", ")", ")", "StubsNeeded", "[", "Symbol", "]", "=", "Signature", ";", "}", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "NaClAlignIndirectJumpTargets", "(", "MF", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "emitXRayTable", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "frame_header_opt", "(", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "mips" ]

[]

[ "<s>", "static", "int", "rs6000_reassociation_width", "(", "unsigned", "int", "opc", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "switch", "(", "rs6000_cpu", ")", "{", "case", "PROCESSOR_POWER8", ":", "case", "PROCESSOR_POWER9", ":", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "1", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "4", ";", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "return", "opc", "==", "MULT_EXPR", "?", "4", ":", "6", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "4", ";", "break", ";", "default", ":", "break", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "reassociation", "width", "to", "be", "used", "in", "reassociate_bb", ".", "This", "takes", "into", "account", "how", "many", "parallel", "operations", "we", "can", "actually", "do", "of", "a", "given", "type", ",", "and", "also", "the", "latency", ".", "P8", ":", "int", "add/sub", "6/cycle", "mul", "2/cycle", "vect", "add/sub/mul", "2/cycle", "fp", "add/sub/mul", "2/cycle", "dfp", "1/cycle" ]

[ "powerpcspe", "1", "4", "4", "6", "4", "1" ]

[]

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

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

[ "PowerPC" ]

[]

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

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

[ "Videocore" ]

[]

[ "<s>", "void", "AVRInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AVR", "::", "LDRdPtr", ":", "case", "AVR", "::", "LDRdPtrPi", ":", "case", "AVR", "::", "LDRdPtrPd", ":", "O", "<<", "\"\\tld\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "if", "(", "Opcode", "==", "AVR", "::", "LDRdPtrPd", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "AVR", "::", "LDRdPtrPi", ")", "O", "<<", "'+'", ";", "break", ";", "case", "AVR", "::", "STPtrRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "break", ";", "case", "AVR", "::", "STPtrPiRr", ":", "case", "AVR", "::", "STPtrPdRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "if", "(", "Opcode", "==", "AVR", "::", "STPtrPdRr", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "AVR", "::", "STPtrPiRr", ")", "O", "<<", "'+'", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "2", ",", "O", ")", ";", "break", ";", "default", ":", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "AVR", "AVR", "AVR::LDRdPtr", "AVR::LDRdPtrPi", "AVR::LDRdPtrPd", "\"\\tld\\t\"", "0", "\", \"", "AVR::LDRdPtrPd", "1", "AVR::LDRdPtrPi", "AVR::STPtrRr", "\"\\tst\\t\"", "0", "\", \"", "1", "AVR::STPtrPiRr", "AVR::STPtrPdRr", "\"\\tst\\t\"", "AVR::STPtrPdRr", "1", "AVR::STPtrPiRr", "\", \"", "2" ]

[]

[ "<s>", "int", "AArch64FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "IgnoreSPUpdates", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset from the SP for \"", "<<", "FI", "<<", "\" is \"", "<<", "MFI", ".", "getObjectOffset", "(", "FI", ")", "<<", "\"\\n\"", ")", ";", "FrameReg", "=", "AArch64", "::", "SP", ";", "return", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "}", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "AArch64", "AArch64", "\"Offset from the SP for \"", "\" is \"", "\"\\n\"", "AArch64::SP" ]

[]

[ "<s>", "int", "HexagonConvergingVLIWScheduler", "::", "SchedulingCost", "(", "ReadyQueue", "&", "Q", ",", "SUnit", "*", "SU", ",", "SchedCandidate", "&", "Candidate", ",", "RegPressureDelta", "&", "Delta", ",", "bool", "verbose", ")", "{", "int", "ResCount", "=", "ConvergingVLIWScheduler", "::", "SchedulingCost", "(", "Q", ",", "SU", ",", "Candidate", ",", "Delta", ",", "verbose", ")", ";", "if", "(", "!", "SU", "||", "SU", "->", "isScheduled", ")", "return", "ResCount", ";", "auto", "&", "QST", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "QII", "=", "*", "QST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "SU", "->", "isInstr", "(", ")", "&&", "QII", ".", "mayBeCurLoad", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ")", "{", "if", "(", "Q", ".", "getID", "(", ")", "==", "TopQID", "&&", "Top", ".", "ResourceModel", "->", "isResourceAvailable", "(", "SU", ",", "true", ")", ")", "{", "ResCount", "+=", "PriorityTwo", ";", "LLVM_DEBUG", "(", "if", "(", "verbose", ")", "dbgs", "(", ")", "<<", "\"C|\"", ")", ";", "}", "else", "if", "(", "Q", ".", "getID", "(", ")", "==", "BotQID", "&&", "Bot", ".", "ResourceModel", "->", "isResourceAvailable", "(", "SU", ",", "false", ")", ")", "{", "ResCount", "+=", "PriorityTwo", ";", "LLVM_DEBUG", "(", "if", "(", "verbose", ")", "dbgs", "(", ")", "<<", "\"C|\"", ")", ";", "}", "}", "return", "ResCount", ";", "}", "</s>" ]

[ "Single", "point", "to", "compute", "overall", "scheduling", "cost", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"C|\"", "\"C|\"" ]

[]

[ "<s>", "bool", "SPIRVOCLRegularizer", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "visit", "(", "F", ")", ";", "for", "(", "auto", "&", "OldNew", ":", "Old2NewFuncs", ")", "{", "auto", "*", "OldF", "=", "OldNew", ".", "first", ";", "auto", "*", "NewF", "=", "OldNew", ".", "second", ";", "NewF", "->", "takeName", "(", "OldF", ")", ";", "OldF", "->", "eraseFromParent", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "static", "bool", "tilegx_current_function_is_leaf", "(", "void", ")", "{", "return", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "machine", "->", "calls_tls_get_addr", ";", "}", "</s>" ]

[ "Return", "whether", "the", "current", "function", "is", "leaf", ".", "This", "takes", "into", "account", "whether", "the", "function", "calls", "tls_get_addr", "." ]

[ "tilegx" ]

[]

[ "<s>", "static", "tree", "c6x_build_builtin_va_list", "(", "void", ")", "{", "return", "build_pointer_type", "(", "char_type_node", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "as", "__builtin_va_list", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "AMDGPUInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

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

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

[ "LoongArch", "\"Invalid type access!\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Immed", ")", "const", "{", "if", "(", "Immed", "<", "0", ")", "Immed", "*=", "-", "1", ";", "return", "isLegalAddImmediate", "(", "Immed", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "1" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_regs", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "rtx_insn", "*", "insn", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", "--", ">", "0", ";", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ",", "true", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_push", "(", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "registers", "in", "the", "prologue", "." ]

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

[]

[ "<s>", "bool", "Thumb2InstrInfo", "::", "isLegalToSplitMBBAt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "while", "(", "MBBI", "->", "isDebugValue", "(", ")", ")", "{", "++", "MBBI", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "}", "unsigned", "PredReg", "=", "0", ";", "return", "getITInstrPredicate", "(", "MBBI", ",", "PredReg", ")", "==", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "legal", "to", "split", "the", "given", "basic", "block", "at", "the", "specified", "instruction", "(", "i.e", "." ]

[ "ARM", "0", "ARMCC::AL" ]

[]

[ "<s>", "static", "void", "aarch64_emit_atomic_swap", "(", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "value", ",", "rtx", "mem", ",", "rtx", "model", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "gen", "=", "gen_aarch64_atomic_swpqi", ";", "break", ";", "case", "HImode", ":", "gen", "=", "gen_aarch64_atomic_swphi", ";", "break", ";", "case", "SImode", ":", "gen", "=", "gen_aarch64_atomic_swpsi", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_aarch64_atomic_swpdi", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "mem", ",", "value", ",", "model", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "atomic", "swap", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "cris_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "(", "(", "mode", "==", "CCmode", "||", "regno", "!=", "CRIS_CC0_REGNUM", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "||", "regno", "!=", "CRIS_MOF_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "CRIS", "permits", "all", "registers", "to", "hold", "all", "modes", ".", "Well", ",", "except", "for", "the", "condition-code", "register", ".", "And", "we", "ca", "n't", "hold", "larger-than-register", "size", "modes", "in", "the", "last", "special", "register", "that", "can", "hold", "a", "full", "32", "bits", "." ]

[ "cris" ]

[]

[ "<s>", "static", "bool", "mips_load_call_address", "(", "enum", "mips_call_type", "type", ",", "rtx", "dest", ",", "rtx", "addr", ")", "{", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "!", "(", "type", "==", "MIPS_CALL_SIBCALL", "&&", "TARGET_CALL_SAVED_GP", ")", "&&", "mips_ok_for_lazy_binding_p", "(", "addr", ")", ")", "{", "addr", "=", "mips_got_load", "(", "dest", ",", "addr", ",", "SYMBOL_GOTOFF_CALL", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "addr", ")", ")", ";", "return", "true", ";", "}", "else", "{", "mips_emit_move", "(", "dest", ",", "addr", ")", ";", "return", "false", ";", "}", "}", "</s>" ]

[ "Load", "function", "address", "ADDR", "into", "register", "DEST", ".", "SIBCALL_P", "is", "true", "if", "the", "address", "is", "needed", "for", "a", "sibling", "call", "." ]

[ "mips" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "getStackGrowthDirection", "(", ")", "==", "TargetFrameLowering", "::", "StackGrowsDown", "&&", "\"Upwards growing stack unsupported\"", ")", ";", "int", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ";", "int64_t", "SVEStackSize", "=", "assignSVEStackObjectOffsets", "(", "MFI", ",", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ")", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "AFI", "->", "setStackSizeSVE", "(", "alignTo", "(", "SVEStackSize", ",", "16U", ")", ")", ";", "AFI", "->", "setMinMaxSVECSFrameIndex", "(", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ")", ";", "if", "(", "!", "MF", ".", "hasEHFunclets", "(", ")", ")", "return", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "int64_t", "FixedObject", "=", "getFixedObjectSize", "(", "MF", ",", "AFI", ",", "true", ",", "false", ")", ";", "int", "UnwindHelpFI", "=", "MFI", ".", "CreateFixedObject", "(", "8", ",", "-", "FixedObject", ",", "false", ")", ";", "EHInfo", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "DebugLoc", "DL", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "RS", "->", "backward", "(", "std", "::", "prev", "(", "MBBI", ")", ")", ";", "unsigned", "DstReg", "=", "RS", "->", "FindUnusedReg", "(", "&", "AArch64", "::", "GPR64commonRegClass", ")", ";", "assert", "(", "DstReg", "&&", "\"There must be a free register after frame setup\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "MOVi64imm", ")", ",", "DstReg", ")", ".", "addImm", "(", "-", "2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "STURXi", ")", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "UnwindHelpFI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AArch64", "AArch64", "\"Upwards growing stack unsupported\"", "AArch64", "AArch64", "16U", "8", "AArch64::GPR64commonRegClass", "\"There must be a free register after frame setup\"", "AArch64::MOVi64imm", "2", "AArch64::STURXi", "0" ]

[]

[ "<s>", "bool", "ARM64MCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetGlobalAddressSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "ARM64", "ARM64", "0", "\"unknown operand type\"" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfo", ">", "(", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "(", "*", "I", ")", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "1", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "*", "I", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "*", "I", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "assert", "(", "Stack", ".", "empty", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "SI", "1" ]

[]

[ "<s>", "bool", "MipsCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "JTI", "=", "(", "(", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "(", "const", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "const", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MCE", ".", "setModuleInfo", "(", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "SDValue", "MMIXTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "IsVarArg", ")", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_MMIX", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "report_fatal_error", "(", "\"Defined with too many args\"", ")", ";", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "RegVT", "!=", "MVT", "::", "i64", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ")", ";", "report_fatal_error", "(", "\"unhandled argument type\"", ")", ";", "}", "const", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "MMIX", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgIn", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgIn", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "ISD::InputArg", "\"Unsupported calling convention\"", "\"VarArg not supported\"", "16", "MMIX", "\"Defined with too many args\"", "MVT::i64", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "\"unhandled argument type\"", "MMIX::GPRRegClass" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "PPCFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Load", ":", "return", "SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "IndirectBr", ":", "return", "SelectIndirectBr", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "SelectIToFP", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "SelectIToFP", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "FPToSI", ":", "return", "SelectFPToI", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "SelectFPToI", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "Add", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "ADD", ")", ";", "case", "Instruction", "::", "Or", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "OR", ")", ";", "case", "Instruction", "::", "Sub", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "SUB", ")", ";", "case", "Instruction", "::", "Call", ":", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSAIX", "(", ")", ")", "break", ";", "return", "selectCall", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "SelectIntExt", "(", "I", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "PowerPC", "PPC", "ISD::ADD", "ISD::OR", "ISD::SUB" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "placeDebugValues", "(", ")", "{", "if", "(", "FirstDbgValue", ")", "{", "BB", "->", "splice", "(", "RegionBegin", ",", "BB", ",", "FirstDbgValue", ")", ";", "RegionBegin", "=", "FirstDbgValue", ";", "}", "for", "(", "std", "::", "vector", "<", "std", "::", "pair", "<", "MachineInstr", "*", ",", "MachineInstr", "*", ">", ">", "::", "iterator", "DI", "=", "DbgValues", ".", "end", "(", ")", ",", "DE", "=", "DbgValues", ".", "begin", "(", ")", ";", "DI", "!=", "DE", ";", "--", "DI", ")", "{", "std", "::", "pair", "<", "MachineInstr", "*", ",", "MachineInstr", "*", ">", "P", "=", "*", "prior", "(", "DI", ")", ";", "MachineInstr", "*", "DbgValue", "=", "P", ".", "first", ";", "MachineBasicBlock", "::", "instr_iterator", "OrigPrevMI", "=", "P", ".", "second", ";", "while", "(", "OrigPrevMI", "->", "isBundledWithSucc", "(", ")", ")", "{", "OrigPrevMI", "++", ";", "}", "moveInstruction", "(", "DbgValue", ",", "++", "OrigPrevMI", ")", ";", "}", "DbgValues", ".", "clear", "(", ")", ";", "FirstDbgValue", "=", "NULL", ";", "}", "</s>" ]

[ "Reinsert", "debug_values", "recorded", "in", "ScheduleDAGInstrs", ":", ":DbgValues", "." ]

[ "Patmos" ]

[]

[ "<s>", "const", "uint32_t", "*", "AVRRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "(", "(", "CC", "==", "CallingConv", "::", "AVR_INTR", "||", "CC", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "?", "CSR_Interrupts_RegMask", ":", "CSR_Normal_RegMask", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "bool", "Z80oldRegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "return", "false", ";", "const", "Z80oldSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "Z80oldSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Reg", "==", "Z80old", "::", "AF", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "PUSH16AF", ")", ")", ";", "}", "else", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "MI", ";", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "II", "->", "modifiesRegister", "(", "Reg", ",", "TRI", ")", ")", "{", "UseMI", "=", "II", ";", "}", "}", "if", "(", "Reg", "==", "Z80old", "::", "AF", ")", "{", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "POP16AF", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "POP16r", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "Z80old", "Z80old", "Z80old", "Z80old", "Z80old::AF", "Z80old::PUSH16AF", "Z80old::PUSH16r", "Z80old::AF", "Z80old::POP16AF", "Z80old::POP16r" ]

[]

[ "<s>", "static", "bool", "must_reload_pic_reg_p", "(", "void", ")", "{", "struct", "cgraph_local_info", "*", "i", "=", "NULL", ";", "if", "(", "!", "TARGET_DSBT", ")", "return", "false", ";", "i", "=", "cgraph_node", "::", "local_info", "(", "current_function_decl", ")", ";", "if", "(", "(", "crtl", "->", "uses_pic_offset_table", "||", "!", "crtl", "->", "is_leaf", ")", "&&", "!", "i", "->", "local", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "need", "to", "save", "and", "modify", "the", "PIC", "register", "in", "the", "prologue", "." ]

[ "c6x" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "(", "Fn", ".", "getRegInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_iterator", "It", "=", "MRI", "->", "def_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "MI", ")", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "RemapChan", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "static", "tree", "gen_stdcall_or_fastcall_suffix", "(", "tree", "decl", ",", "bool", "fastcall", ")", "{", "int", "total", "=", "0", ";", "const", "char", "*", "asmname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "char", "*", "newsym", ";", "char", "*", "p", ";", "tree", "formal_type", ";", "if", "(", "*", "asmname", "==", "'*'", "||", "strchr", "(", "asmname", ",", "'@'", ")", ")", "return", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ";", "formal_type", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "formal_type", "!=", "NULL_TREE", ")", "{", "if", "(", "TREE_VALUE", "(", "tree_last", "(", "formal_type", ")", ")", "!=", "void_type_node", ")", "return", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ";", "while", "(", "TREE_VALUE", "(", "formal_type", ")", "!=", "void_type_node", "&&", "COMPLETE_TYPE_P", "(", "TREE_VALUE", "(", "formal_type", ")", ")", ")", "{", "int", "parm_size", "=", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "TREE_VALUE", "(", "formal_type", ")", ")", ")", ";", "parm_size", "=", "(", "(", "parm_size", "+", "PARM_BOUNDARY", "-", "1", ")", "/", "PARM_BOUNDARY", "*", "PARM_BOUNDARY", ")", ";", "total", "+=", "parm_size", ";", "formal_type", "=", "TREE_CHAIN", "(", "formal_type", ")", ";", "\\", "}", "}", "newsym", "=", "alloca", "(", "1", "+", "strlen", "(", "asmname", ")", "+", "1", "+", "8", "+", "1", ")", ";", "p", "=", "newsym", ";", "if", "(", "fastcall", ")", "*", "p", "++", "=", "FASTCALL_PREFIX", ";", "sprintf", "(", "p", ",", "\"%s@%d\"", ",", "asmname", ",", "total", "/", "BITS_PER_UNIT", ")", ";", "return", "get_identifier", "(", "newsym", ")", ";", "}", "</s>" ]

[ "Return", "string", "which", "is", "the", "former", "assembler", "name", "modified", "with", "a", "suffix", "consisting", "of", "an", "atsign", "(", "@", ")", "followed", "by", "the", "number", "of", "bytes", "of", "arguments", ".", "If", "FASTCALL", "is", "true", ",", "also", "add", "the", "FASTCALL_PREFIX", "." ]

[ "i386", "0", "1", "1", "1", "8", "1", "\"%s@%d\"" ]

[]

[ "<s>", "static", "bool", "is_cmp", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_type", "type", ";", "type", "=", "get_attr_type", "(", "insn", ")", ";", "return", "(", "type", "==", "TYPE_TEST", "||", "type", "==", "TYPE_ICMP", "||", "type", "==", "TYPE_FCMP", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COMPARE", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "insn", "is", "a", "compare", "instruction", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "AMDGPUAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "std", "::", "vector", "<", "Function", "*", ">", "FuncsToClone", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "use_empty", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "FuncsToClone", ".", "push_back", "(", "&", "F", ")", ";", "}", "for", "(", "Function", "*", "F", ":", "FuncsToClone", ")", "{", "ValueToValueMapTy", "VMap", ";", "Function", "*", "NewFunc", "=", "CloneFunction", "(", "F", ",", "VMap", ",", "false", ")", ";", "NewFunc", "->", "setLinkage", "(", "GlobalValue", "::", "InternalLinkage", ")", ";", "M", ".", "getFunctionList", "(", ")", ".", "push_back", "(", "NewFunc", ")", ";", "F", "->", "replaceAllUsesWith", "(", "NewFunc", ")", ";", "}", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "{", "F", ".", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

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

[ "LEG" ]

[]

[ "<s>", "bool", "NyuziFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_pblendv", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "which", ",", "nelt", "=", "d", "->", "nelt", ";", "struct", "expand_vec_perm_d", "dcopy", ",", "dcopy1", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "bool", "ok", ";", "if", "(", "d", "->", "one_operand_p", ")", "return", "false", ";", "if", "(", "TARGET_AVX2", "&&", "GET_MODE_SIZE", "(", "vmode", ")", "==", "32", ")", ";", "else", "if", "(", "TARGET_AVX", "&&", "(", "vmode", "==", "V4DFmode", "||", "vmode", "==", "V8SFmode", ")", ")", ";", "else", "if", "(", "TARGET_SSE4_1", "&&", "(", "GET_MODE_SIZE", "(", "vmode", ")", "==", "4", "||", "GET_MODE_SIZE", "(", "vmode", ")", "==", "8", "||", "GET_MODE_SIZE", "(", "vmode", ")", "==", "16", ")", ")", ";", "else", "return", "false", ";", "for", "(", "i", "=", "0", ",", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "if", "(", "e", "!=", "i", ")", "which", "|=", "(", "e", "<", "nelt", "?", "1", ":", "2", ")", ";", "}", "if", "(", "which", "!=", "1", "&&", "which", "!=", "2", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", "&&", "GET_MODE_SIZE", "(", "vmode", ")", "==", "16", ")", "return", "true", ";", "dcopy", "=", "*", "d", ";", "if", "(", "which", "==", "2", ")", "dcopy", ".", "op0", "=", "dcopy", ".", "op1", "=", "d", "->", "op1", ";", "else", "dcopy", ".", "op0", "=", "dcopy", ".", "op1", "=", "d", "->", "op0", ";", "if", "(", "!", "d", "->", "testing_p", ")", "dcopy", ".", "target", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "dcopy", ".", "one_operand_p", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "dcopy", ".", "perm", "[", "i", "]", "=", "d", "->", "perm", "[", "i", "]", "&", "(", "nelt", "-", "1", ")", ";", "ok", "=", "expand_vec_perm_1", "(", "&", "dcopy", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "vmode", ")", "!=", "16", "&&", "!", "ok", ")", "return", "false", ";", "else", "gcc_assert", "(", "ok", ")", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "dcopy1", "=", "*", "d", ";", "if", "(", "which", "==", "2", ")", "dcopy1", ".", "op1", "=", "dcopy", ".", "target", ";", "else", "dcopy1", ".", "op0", "=", "dcopy", ".", "target", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "dcopy1", ".", "perm", "[", "i", "]", "=", "(", "(", "d", "->", "perm", "[", "i", "]", ">=", "nelt", ")", "?", "(", "nelt", "+", "i", ")", ":", "i", ")", ";", "ok", "=", "expand_vec_perm_blend", "(", "&", "dcopy1", ")", ";", "gcc_assert", "(", "ok", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_const_1", ".", "Try", "to", "simplify", "the", "permutation", "using", "the", "SSE4_1", "pblendv", "instruction", ".", "Potentially", "reduces", "permutation", "from", "2", "pshufb", "and", "or", "to", "1", "pshufb", "and", "pblendv", "." ]

[ "i386", "32", "4", "8", "16", "0", "0", "1", "2", "1", "2", "16", "2", "0", "1", "16", "2", "0" ]

[]

[ "<s>", "static", "bool", "m68k_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_m5200", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_5200", ";", "return", "true", ";", "case", "OPT_m5206e", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_5200", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m528x", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_528x", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m5307", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_CFV3", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m5407", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_CFV4", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m68000", ":", "case", "OPT_mc68000", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "return", "true", ";", "case", "OPT_m68020", ":", "case", "OPT_mc68020", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "MASK_68020", "|", "MASK_BITFIELD", ";", "return", "true", ";", "case", "OPT_m68020_40", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "MASK_BITFIELD", "|", "MASK_68881", "|", "MASK_68020", "|", "MASK_68040", ";", "return", "true", ";", "case", "OPT_m68020_60", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "(", "MASK_BITFIELD", "|", "MASK_68881", "|", "MASK_68020", "|", "MASK_68040", "|", "MASK_68060", ")", ";", "return", "true", ";", "case", "OPT_m68030", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "MASK_68020", "|", "MASK_68030", "|", "MASK_BITFIELD", ";", "return", "true", ";", "case", "OPT_m68040", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "(", "MASK_68020", "|", "MASK_68881", "|", "MASK_BITFIELD", "|", "MASK_68040_ONLY", "|", "MASK_68040", ")", ";", "return", "true", ";", "case", "OPT_m68060", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "(", "MASK_68020", "|", "MASK_68881", "|", "MASK_BITFIELD", "|", "MASK_68040_ONLY", "|", "MASK_68060", ")", ";", "return", "true", ";", "case", "OPT_m68302", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "return", "true", ";", "case", "OPT_m68332", ":", "case", "OPT_mcpu32", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_68020", ";", "return", "true", ";", "case", "OPT_mshared_library_id_", ":", "if", "(", "value", ">", "MAX_LIBRARY_ID", ")", "error", "(", "\"-mshared-library-id=%s is not between 0 and %d\"", ",", "arg", ",", "MAX_LIBRARY_ID", ")", ";", "else", "asprintf", "(", "(", "char", "*", "*", ")", "&", "m68k_library_id_string", ",", "\"%d\"", ",", "(", "value", "*", "-", "4", ")", "-", "4", ")", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "m68k", "\"-mshared-library-id=%s is not between 0 and %d\"", "\"%d\"", "4", "4" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequiredID", "(", "LoopSimplifyID", ")", ";", "AU", ".", "addRequiredID", "(", "LCSSAID", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "arm_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", ",", "mem", ",", "a_tramp", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "if", "(", "TARGET_FDPIC", ")", "{", "rtx", "funcdesc", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "fnaddr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "funcdesc", ")", ";", "rtx", "gotaddr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "funcdesc", ",", "4", ")", ")", ";", "rtx", "trampoline_code_start", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "TARGET_THUMB2", "?", "9", ":", "8", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "trampoline_code_start", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "20", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "24", ")", ";", "emit_move_insn", "(", "mem", ",", "gotaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "28", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}", "else", "{", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "TARGET_32BIT", "?", "8", ":", "12", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "TARGET_32BIT", "?", "12", ":", "16", ")", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}", "a_tramp", "=", "XEXP", "(", "m_tramp", ",", "0", ")", ";", "maybe_emit_call_builtin___clear_cache", "(", "a_tramp", ",", "plus_constant", "(", "ptr_mode", ",", "a_tramp", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "." ]

[ "arm", "0", "4", "0", "9", "8", "0", "4", "20", "24", "28", "8", "12", "12", "16", "0", "0" ]

[]

[ "<s>", "bool", "BlackfinRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "adjustsStack", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "Blackfin" ]

[]

[ "<s>", "static", "bool", "mips_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "8", "&&", "GET_MODE_SIZE", "(", "to", ")", "==", "8", "&&", "INTEGRAL_MODE_P", "(", "from", ")", "&&", "INTEGRAL_MODE_P", "(", "to", ")", ")", "return", "true", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "from", ")", "&&", "MSA_SUPPORTED_MODE_P", "(", "to", ")", ")", "return", "true", ";", "return", "!", "reg_classes_intersect_p", "(", "FP_REGS", ",", "rclass", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "mips", "8", "8" ]

[]

[ "<s>", "enum", "reg_class", "secondary_output_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "secondary_input_reload_class", "(", "class", ",", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "Like", "secondary_input_reload_class", ";", "and", "all", "we", "do", "is", "call", "that", "function", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "nds32_n13_load_to_e1_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "gcc_assert", "(", "get_attr_type", "(", "producer", ")", "==", "TYPE_LOAD", ")", ";", "gcc_assert", "(", "REG_P", "(", "def_reg", ")", "||", "GET_CODE", "(", "def_reg", ")", "==", "SUBREG", ")", ";", "return", "n13_consumed_by_e1_dep_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "Load-Store", "Unit", "(", "E3", ")", "to", "E1", "." ]

[ "nds32" ]

[]

[ "<s>", "const", "SDValue", "&", "getMask", "(", ")", "const", "{", "return", "getOperand", "(", "2", ")", ";", "}", "</s>" ]

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

[ "X86", "2" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseReg", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "LdSt", ".", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "!=", "3", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "||", "(", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "Width", "=", "(", "*", "LdSt", ".", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "BaseReg", "=", "&", "LdSt", ".", "getOperand", "(", "2", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

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

[]

[ "<s>", "bool", "SPIRVCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallLoweringInfo", "&", "Info", ")", "const", "{", "if", "(", "Info", ".", "OrigRet", ".", "Regs", ".", "size", "(", ")", ">", "1", ")", "return", "false", ";", "Register", "ResVReg", "=", "Info", ".", "OrigRet", ".", "Regs", ".", "empty", "(", ")", "?", "Register", "(", "0", ")", ":", "Info", ".", "OrigRet", ".", "Regs", "[", "0", "]", ";", "if", "(", "Info", ".", "Callee", ".", "isGlobal", "(", ")", ")", "{", "auto", "*", "CF", "=", "dyn_cast_or_null", "<", "const", "Function", ">", "(", "Info", ".", "Callee", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "CF", "==", "nullptr", ")", "return", "false", ";", "if", "(", "CF", "->", "isDeclaration", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "OldII", "=", "MIRBuilder", ".", "getInsertPt", "(", ")", ";", "MachineBasicBlock", "&", "OldBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineBasicBlock", "&", "FirstBB", "=", "*", "MIRBuilder", ".", "getMF", "(", ")", ".", "getBlockNumbered", "(", "0", ")", ";", "MIRBuilder", ".", "setInsertPt", "(", "FirstBB", ",", "FirstBB", ".", "instr_end", "(", ")", ")", ";", "SmallVector", "<", "ArrayRef", "<", "Register", ">", ",", "8", ">", "VRegArgs", ";", "SmallVector", "<", "SmallVector", "<", "Register", ",", "1", ">", ",", "8", ">", "ToInsert", ";", "for", "(", "const", "Argument", "&", "Arg", ":", "CF", "->", "args", "(", ")", ")", "{", "if", "(", "MIRBuilder", ".", "getDataLayout", "(", ")", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ToInsert", ".", "push_back", "(", "{", "MIRBuilder", ".", "getMRI", "(", ")", "->", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", "}", ")", ";", "VRegArgs", ".", "push_back", "(", "ToInsert", ".", "back", "(", ")", ")", ";", "}", "FunctionLoweringInfo", "FuncInfo", ";", "lowerFormalArguments", "(", "MIRBuilder", ",", "*", "CF", ",", "VRegArgs", ",", "FuncInfo", ")", ";", "MIRBuilder", ".", "setInsertPt", "(", "OldBB", ",", "OldII", ")", ";", "}", "}", "if", "(", "!", "ResVReg", ".", "isValid", "(", ")", ")", "{", "ResVReg", "=", "MIRBuilder", ".", "getMRI", "(", ")", "->", "createVirtualRegister", "(", "&", "SPIRV", "::", "IDRegClass", ")", ";", "}", "SPIRVType", "*", "RetType", "=", "GR", "->", "assignTypeToVReg", "(", "Info", ".", "OrigRet", ".", "Ty", ",", "ResVReg", ",", "MIRBuilder", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstr", "(", "SPIRV", "::", "OpFunctionCall", ")", ".", "addDef", "(", "ResVReg", ")", ".", "addUse", "(", "GR", "->", "getSPIRVTypeID", "(", "RetType", ")", ")", ".", "add", "(", "Info", ".", "Callee", ")", ";", "for", "(", "const", "auto", "&", "Arg", ":", "Info", ".", "OrigArgs", ")", "{", "if", "(", "Arg", ".", "Regs", ".", "size", "(", ")", ">", "1", ")", "return", "false", ";", "MIB", ".", "addUse", "(", "Arg", ".", "Regs", "[", "0", "]", ")", ";", "}", "return", "MIB", ".", "constrainAllUses", "(", "MIRBuilder", ".", "getTII", "(", ")", ",", "*", "ST", ".", "getRegisterInfo", "(", ")", ",", "*", "ST", ".", "getRegBankInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "SPIRV", "SPIRV", "1", "0", "0", "0", "8", "1", "8", "32", "SPIRV::IDRegClass", "SPIRV", "SPIRV::OpFunctionCall", "SPIRV", "1", "0" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectWrite", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "unsigned", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "MOVA", ",", "AMDGPU", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "AddrReg", ",", "ValueReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "Mov", ",", "AMDGPU", "::", "OpName", "::", "dst_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "write", "." ]

[ "R600", "0", "1" ]

[]

[ "<s>", "void", "reset", "(", ")", "override", "{", "static_cast", "<", "RISCVTargetStreamer", "*", ">", "(", "getTargetStreamer", "(", ")", ")", "->", "reset", "(", ")", ";", "MCELFStreamer", "::", "reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "int", "avx_vpermilp_parallel", "(", "rtx", "par", ",", "machine_mode", "mode", ")", "{", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "unsigned", "mask", "=", "0", ";", "unsigned", "char", "ipar", "[", "16", "]", "=", "{", "}", ";", "if", "(", "XVECLEN", "(", "par", ",", "0", ")", "!=", "(", "int", ")", "nelt", ")", "return", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "rtx", "er", "=", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "ei", ";", "if", "(", "!", "CONST_INT_P", "(", "er", ")", ")", "return", "0", ";", "ei", "=", "INTVAL", "(", "er", ")", ";", "if", "(", "ei", ">=", "nelt", ")", "return", "0", ";", "ipar", "[", "i", "]", "=", "ei", ";", "}", "switch", "(", "mode", ")", "{", "case", "V8DFmode", ":", "for", "(", "i", "=", "4", ";", "i", "<", "6", ";", "++", "i", ")", "{", "if", "(", "ipar", "[", "i", "]", "<", "4", "||", "ipar", "[", "i", "]", ">=", "6", ")", "return", "0", ";", "mask", "|=", "(", "ipar", "[", "i", "]", "-", "4", ")", "<<", "i", ";", "}", "for", "(", "i", "=", "6", ";", "i", "<", "8", ";", "++", "i", ")", "{", "if", "(", "ipar", "[", "i", "]", "<", "6", ")", "return", "0", ";", "mask", "|=", "(", "ipar", "[", "i", "]", "-", "6", ")", "<<", "i", ";", "}", "case", "V4DFmode", ":", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "++", "i", ")", "{", "if", "(", "ipar", "[", "i", "]", ">=", "2", ")", "return", "0", ";", "mask", "|=", "ipar", "[", "i", "]", "<<", "i", ";", "}", "for", "(", "i", "=", "2", ";", "i", "<", "4", ";", "++", "i", ")", "{", "if", "(", "ipar", "[", "i", "]", "<", "2", ")", "return", "0", ";", "mask", "|=", "(", "ipar", "[", "i", "]", "-", "2", ")", "<<", "i", ";", "}", "break", ";", "case", "V16SFmode", ":", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "if", "(", "ipar", "[", "i", "]", "+", "8", "!=", "ipar", "[", "i", "+", "8", "]", ")", "return", "0", ";", "case", "V8SFmode", ":", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "if", "(", "ipar", "[", "i", "]", "+", "4", "!=", "ipar", "[", "i", "+", "4", "]", ")", "return", "0", ";", "nelt", "=", "4", ";", "case", "V2DFmode", ":", "case", "V4SFmode", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "mask", "|=", "ipar", "[", "i", "]", "<<", "(", "i", "*", "(", "nelt", "/", "2", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "mask", "+", "1", ";", "}", "</s>" ]

[ "Helper", "for", "avx_vpermilps256_operand", "et", "al", ".", "This", "is", "also", "used", "by", "the", "expansion", "functions", "to", "turn", "the", "parallel", "back", "into", "a", "mask", ".", "The", "return", "value", "is", "0", "for", "no", "match", "and", "the", "imm8+1", "for", "a", "match", "." ]

[ "i386", "0", "16", "0", "0", "0", "0", "0", "0", "4", "6", "4", "6", "0", "4", "6", "8", "6", "0", "6", "0", "2", "2", "0", "2", "4", "2", "0", "2", "0", "8", "8", "8", "0", "0", "4", "4", "4", "0", "4", "0", "2", "1" ]

[]

[ "<s>", "MCSymbol", "*", "Z80oldMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "assert", "(", "!", "MO", ".", "getTargetFlags", "(", ")", "&&", "\"Unknown target flag on GV operand\"", ")", ";", "return", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "Z80old", "Z80old", "\"Unknown target flag on GV operand\"" ]

[]

[ "<s>", "uint64_t", "HexagonInstrInfo", "::", "getType", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "return", "(", "F", ">>", "HexagonII", "::", "TypePos", ")", "&", "HexagonII", "::", "TypeMask", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonII::TypePos", "HexagonII::TypeMask" ]

[]

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

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

[ "ECLair" ]

[]

[ "<s>", "bool", "WebAssemblyAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "==", "0", ")", "return", "true", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "++", "i", ")", "OW", "->", "write8", "(", "WebAssembly", "::", "Nop", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "0", "WebAssembly::Nop" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "RISCVISD", "::", "RET_FLAG", ":", "return", "\"RISCVISD::RET_FLAG\"", ";", "case", "RISCVISD", "::", "CALL", ":", "return", "\"RISCVISD::CALL\"", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "return", "\"RISCVISD::SELECT_CC\"", ";", "case", "RISCVISD", "::", "BuildPairF64", ":", "return", "\"RISCVISD::BuildPairF64\"", ";", "case", "RISCVISD", "::", "SplitF64", ":", "return", "\"RISCVISD::SplitF64\"", ";", "case", "RISCVISD", "::", "TAIL", ":", "return", "\"RISCVISD::TAIL\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER", "RISCVISD::RET_FLAG", "\"RISCVISD::RET_FLAG\"", "RISCVISD::CALL", "\"RISCVISD::CALL\"", "RISCVISD::SELECT_CC", "\"RISCVISD::SELECT_CC\"", "RISCVISD::BuildPairF64", "\"RISCVISD::BuildPairF64\"", "RISCVISD::SplitF64", "\"RISCVISD::SplitF64\"", "RISCVISD::TAIL", "\"RISCVISD::TAIL\"" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonBranchRelaxation", "(", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ",", "false", ")", ";", "if", "(", "EnableGenMux", ")", "addPass", "(", "createHexagonGenMux", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ",", "false", ")", ";", "}", "if", "(", "EnableVectorPrint", ")", "addPass", "(", "createHexagonVectorPrint", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonCallFrameInformation", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SITargetLowering", "::", "getRegClassFor", "(", "MVT", "VT", ",", "bool", "isDivergent", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TargetLoweringBase", "::", "getRegClassFor", "(", "VT", ",", "false", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_1RegClass", "&&", "!", "isDivergent", ")", "return", "Subtarget", "->", "getWavefrontSize", "(", ")", "==", "64", "?", "&", "AMDGPU", "::", "SReg_64RegClass", ":", "&", "AMDGPU", "::", "SReg_32RegClass", ";", "if", "(", "!", "TRI", "->", "isSGPRClass", "(", "RC", ")", "&&", "!", "isDivergent", ")", "return", "TRI", "->", "getEquivalentSGPRClass", "(", "RC", ")", ";", "else", "if", "(", "TRI", "->", "isSGPRClass", "(", "RC", ")", "&&", "isDivergent", ")", "return", "TRI", "->", "getEquivalentVGPRClass", "(", "RC", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "that", "should", "be", "used", "for", "the", "specified", "value", "type", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::VReg_1RegClass", "64", "AMDGPU::SReg_64RegClass", "AMDGPU::SReg_32RegClass" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "arm_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "int", "i", ",", "nelt", ",", "which", ";", "if", "(", "!", "VALID_NEON_DREG_MODE", "(", "vmode", ")", "&&", "!", "VALID_NEON_QREG_MODE", "(", "vmode", ")", ")", "return", "false", ";", "d", ".", "target", "=", "target", ";", "if", "(", "op0", ")", "{", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "}", "if", "(", "op1", ")", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "vmode", "=", "vmode", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "d", ".", "vmode", ")", ")", ";", "d", ".", "testing_p", "=", "!", "target", ";", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "int", "ei", "=", "sel", "[", "i", "]", "&", "(", "2", "*", "nelt", "-", "1", ")", ";", "which", "|=", "(", "ei", "<", "nelt", "?", "1", ":", "2", ")", ";", "}", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "3", ":", "d", ".", "one_vector_p", "=", "false", ";", "if", "(", "d", ".", "testing_p", "||", "!", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "break", ";", "case", "2", ":", "d", ".", "op0", "=", "op1", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "case", "1", ":", "d", ".", "op1", "=", "op0", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "}", "d", ".", "perm", ".", "new_vector", "(", "sel", ".", "encoding", "(", ")", ",", "d", ".", "one_vector_p", "?", "1", ":", "2", ",", "nelt", ")", ";", "if", "(", "!", "d", ".", "testing_p", ")", "return", "arm_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "if", "(", "!", "d", ".", "one_vector_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "3", ")", ";", "start_sequence", "(", ")", ";", "bool", "ret", "=", "arm_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "static", "void", "set_reg_plus_d", "(", "int", "reg", ",", "int", "base", ",", "HOST_WIDE_INT", "disp", ",", "int", "note", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "VAL_14_BITS_P", "(", "disp", ")", ")", "{", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "plus_constant", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ",", "disp", ")", ")", ";", "}", "else", "if", "(", "TARGET_64BIT", "&&", "!", "VAL_32_BITS_P", "(", "disp", ")", ")", "{", "rtx", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "delta", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "tmpreg", ",", "basereg", ")", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "delta", ")", ")", ")", ";", "}", "else", "{", "rtx", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "delta", ")", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmpreg", ",", "delta", ")", ")", ";", "}", "if", "(", "DO_FRAME_NOTES", "&&", "note", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "set", "REG", "to", "the", "value", "specified", "by", "BASE+DISP", ".", "Handle", "case", "where", "DISP", ">", "8k", "by", "using", "the", "add_high_const", "patterns", ".", "Note", "in", "DISP", ">", "8k", "case", ",", "we", "will", "leave", "the", "high", "part", "of", "the", "address", "in", "%", "r1", ".", "There", "is", "code", "in", "expand_hppa_", "{", "prologue", ",", "epilogue", "}", "that", "knows", "this", "." ]

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

[]

[ "<s>", "OperandMatchResultTy", "AVRAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "StartLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "RegNo", "=", "parseRegister", "(", "true", ")", ";", "EndLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "RegNo", "==", "AVR", "::", "NoRegister", ")", "return", "MatchOperand_NoMatch", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::NoRegister" ]

[]