Datasets:

docz-ict

/

ComBack

like 2

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "CMPri", ":", "case", "ARM", "::", "t2CMPri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "ARM", "::", "CMPrr", ":", "case", "ARM", "::", "t2CMPrr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "ARM", "::", "TSTri", ":", "case", "ARM", "::", "t2TSTri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "ARM", "ARM", "ARM::CMPri", "ARM::t2CMPri", "0", "0", "0", "1", "ARM::CMPrr", "ARM::t2CMPrr", "0", "1", "0", "0", "ARM::TSTri", "ARM::t2TSTri", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "int", "legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "enum", "reg_class", "r", "=", "NO_REGS", ";", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"mode: (%s) %s %s %s %s:\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "strict", "?", "\"(strict)\"", ":", "\"\"", ",", "reload_completed", "?", "\"(reload_completed)\"", ":", "\"\"", ",", "reload_in_progress", "?", "\"(reload_in_progress)\"", ":", "\"\"", ",", "reg_renumber", "?", "\"(reg_renumber)\"", ":", "\"\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", "&&", "reg_renumber", ")", "fprintf", "(", "stderr", ",", "\"(r%d ---> r%d)\"", ",", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "REG_OK_FOR_BASE_STRICT_P", "(", "x", ")", ":", "REG_OK_FOR_BASE_NOSTRICT_P", "(", "x", ")", ")", ")", "r", "=", "POINTER_REGS", ";", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "r", "=", "ALL_REGS", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "{", "int", "fit", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", ";", "if", "(", "fit", ")", "{", "if", "(", "!", "strict", "||", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG_Y", "||", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG_Z", ")", "r", "=", "BASE_POINTER_REGS", ";", "if", "(", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", "||", "XEXP", "(", "x", ",", "0", ")", "==", "arg_pointer_rtx", ")", "r", "=", "BASE_POINTER_REGS", ";", "}", "else", "if", "(", "frame_pointer_needed", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", ")", "r", "=", "POINTER_Y_REGS", ";", "}", "else", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "(", "strict", "?", "REG_OK_FOR_BASE_STRICT_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ":", "REG_OK_FOR_BASE_NOSTRICT_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "r", "=", "POINTER_REGS", ";", "}", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\" ret = %c\\n\"", ",", "r", "+", "'0'", ")", ";", "}", "return", "r", "==", "NO_REGS", "?", "0", ":", "(", "int", ")", "r", ";", "}", "</s>" ]

[ "legitimate_address_p", "returns", "1", "if", "it", "recognizes", "an", "RTL", "expression", "``", "x", "''", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", "." ]

[ "avr", "\"mode: (%s) %s %s %s %s:\"", "\"(strict)\"", "\"\"", "\"(reload_completed)\"", "\"\"", "\"(reload_in_progress)\"", "\"\"", "\"(reg_renumber)\"", "\"\"", "0", "1", "1", "0", "1", "\"(r%d ---> r%d)\"", "0", "0", "0", "1", "1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "\" ret = %c\\n\"", "0" ]

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "PowerPC" ]

[]

[ "<s>", "const", "AArch64InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "SNESRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "SNES", "SNES" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getMaxSupportedInterleaveFactor", "(", ")", "const", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "4", ";", "if", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "4", ";", "return", "TargetLoweringBase", "::", "getMaxSupportedInterleaveFactor", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "maximum", "supported", "factor", "for", "interleaved", "memory", "accesses", "." ]

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

[]

[ "<s>", "void", "s390_initialize_trampoline", "(", "rtx", "addr", ",", "rtx", "fnaddr", ",", "rtx", "cxt", ")", "{", "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "plus_constant", "(", "addr", ",", "(", "TARGET_64BIT", "?", "16", ":", "8", ")", ")", ")", ")", ",", "cxt", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "plus_constant", "(", "addr", ",", "(", "TARGET_64BIT", "?", "24", ":", "12", ")", ")", ")", ")", ",", "fnaddr", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "s390", "16", "8", "24", "12" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ThumbRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ")", "return", "ARMBaseRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ",", "MF", ")", ";", "if", "(", "ARM", "::", "tGPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "&", "ARM", "::", "tGPRRegClass", ";", "return", "ARMBaseRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ",", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "ARM", "ARM", "ARM", "ARM::tGPRRegClass", "ARM::tGPRRegClass", "ARM" ]

[]

[ "<s>", "const", "XtensaRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "const", "int", "Opcode", ",", "const", "int", "Offset", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "LDriw", ":", "case", "Hexagon", "::", "LDriw_indexed", ":", "case", "Hexagon", "::", "LDriw_f", ":", "case", "Hexagon", "::", "STriw_indexed", ":", "case", "Hexagon", "::", "STriw", ":", "case", "Hexagon", "::", "STriw_f", ":", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrid", ":", "case", "Hexagon", "::", "LDrid_indexed", ":", "case", "Hexagon", "::", "LDrid_f", ":", "case", "Hexagon", "::", "STrid", ":", "case", "Hexagon", "::", "STrid_indexed", ":", "case", "Hexagon", "::", "STrid_f", ":", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrih", ":", "case", "Hexagon", "::", "LDriuh", ":", "case", "Hexagon", "::", "STrih", ":", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrib", ":", "case", "Hexagon", "::", "STrib", ":", "case", "Hexagon", "::", "LDriub", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "ADD_ri", ":", "case", "Hexagon", "::", "TFR_FI", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "MemOPw_ADDi_V4", ":", "case", "Hexagon", "::", "MemOPw_SUBi_V4", ":", "case", "Hexagon", "::", "MemOPw_ADDr_V4", ":", "case", "Hexagon", "::", "MemOPw_SUBr_V4", ":", "case", "Hexagon", "::", "MemOPw_ANDr_V4", ":", "case", "Hexagon", "::", "MemOPw_ORr_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "255", ")", ";", "case", "Hexagon", "::", "MemOPh_ADDi_V4", ":", "case", "Hexagon", "::", "MemOPh_SUBi_V4", ":", "case", "Hexagon", "::", "MemOPh_ADDr_V4", ":", "case", "Hexagon", "::", "MemOPh_SUBr_V4", ":", "case", "Hexagon", "::", "MemOPh_ANDr_V4", ":", "case", "Hexagon", "::", "MemOPh_ORr_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "127", ")", ";", "case", "Hexagon", "::", "MemOPb_ADDi_V4", ":", "case", "Hexagon", "::", "MemOPb_SUBi_V4", ":", "case", "Hexagon", "::", "MemOPb_ADDr_V4", ":", "case", "Hexagon", "::", "MemOPb_SUBr_V4", ":", "case", "Hexagon", "::", "MemOPb_ANDr_V4", ":", "case", "Hexagon", "::", "MemOPb_ORr_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "63", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "return", "true", ";", "case", "Hexagon", "::", "LOOP0_i", ":", "return", "isUInt", "<", "10", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "Hexagon", "Hexagon", "Hexagon::LDriw", "Hexagon::LDriw_indexed", "Hexagon::LDriw_f", "Hexagon::STriw_indexed", "Hexagon::STriw", "Hexagon::STriw_f", "Hexagon", "Hexagon", "Hexagon::LDrid", "Hexagon::LDrid_indexed", "Hexagon::LDrid_f", "Hexagon::STrid", "Hexagon::STrid_indexed", "Hexagon::STrid_f", "Hexagon", "Hexagon", "Hexagon::LDrih", "Hexagon::LDriuh", "Hexagon::STrih", "Hexagon", "Hexagon", "Hexagon::LDrib", "Hexagon::STrib", "Hexagon::LDriub", "Hexagon", "Hexagon", "Hexagon::ADD_ri", "Hexagon::TFR_FI", "Hexagon", "Hexagon", "Hexagon::MemOPw_ADDi_V4", "Hexagon::MemOPw_SUBi_V4", "Hexagon::MemOPw_ADDr_V4", "Hexagon::MemOPw_SUBr_V4", "Hexagon::MemOPw_ANDr_V4", "Hexagon::MemOPw_ORr_V4", "0", "255", "Hexagon::MemOPh_ADDi_V4", "Hexagon::MemOPh_SUBi_V4", "Hexagon::MemOPh_ADDr_V4", "Hexagon::MemOPh_SUBr_V4", "Hexagon::MemOPh_ANDr_V4", "Hexagon::MemOPh_ORr_V4", "0", "127", "Hexagon::MemOPb_ADDi_V4", "Hexagon::MemOPb_SUBi_V4", "Hexagon::MemOPb_ADDr_V4", "Hexagon::MemOPb_SUBr_V4", "Hexagon::MemOPb_ANDr_V4", "Hexagon::MemOPb_ORr_V4", "0", "63", "Hexagon::STriw_pred", "Hexagon::LDriw_pred", "Hexagon::LOOP0_i", "10", "Hexagon::INLINEASM", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "Cond", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "if", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", "||", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "GPRC_NOR0RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RC_NOX0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "false", ";", "CondCycles", "=", "1", ";", "TrueCycles", "=", "1", ";", "FalseCycles", "=", "1", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "PowerPC", "PPC", "2", "1", "PPC::CTR", "1", "PPC::CTR8", "PPC::GPRCRegClass", "PPC::GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_NOX0RegClass", "1", "1", "1" ]

[]

[ "<s>", "int", "uses_TOC", "(", ")", "{", "rtx", "insn", ";", "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", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ",", "1", ")", "==", "7", ")", "return", "1", ";", "}", "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", "0", "0", "0", "0", "1", "7", "1", "0" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "FoldImmediate", "(", "MachineInstr", "&", "UseMI", ",", "MachineInstr", "&", "DefMI", ",", "Register", "Reg", ",", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "unsigned", "DefOpc", "=", "DefMI", ".", "getOpcode", "(", ")", ";", "if", "(", "DefOpc", "!=", "SystemZ", "::", "LHIMux", "&&", "DefOpc", "!=", "SystemZ", "::", "LHI", "&&", "DefOpc", "!=", "SystemZ", "::", "LGHI", ")", "return", "false", ";", "if", "(", "DefMI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "!=", "Reg", ")", "return", "false", ";", "int32_t", "ImmVal", "=", "(", "int32_t", ")", "DefMI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "UseOpc", "=", "UseMI", ".", "getOpcode", "(", ")", ";", "unsigned", "NewUseOpc", ";", "unsigned", "UseIdx", ";", "int", "CommuteIdx", "=", "-", "1", ";", "bool", "TieOps", "=", "false", ";", "switch", "(", "UseOpc", ")", "{", "case", "SystemZ", "::", "SELRMux", ":", "TieOps", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "SystemZ", "::", "LOCRMux", ":", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "return", "false", ";", "NewUseOpc", "=", "SystemZ", "::", "LOCHIMux", ";", "if", "(", "UseMI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ";", "else", "if", "(", "UseMI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ",", "CommuteIdx", "=", "1", ";", "else", "return", "false", ";", "break", ";", "case", "SystemZ", "::", "SELGR", ":", "TieOps", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "SystemZ", "::", "LOCGR", ":", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "return", "false", ";", "NewUseOpc", "=", "SystemZ", "::", "LOCGHI", ";", "if", "(", "UseMI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ";", "else", "if", "(", "UseMI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ",", "CommuteIdx", "=", "1", ";", "else", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "CommuteIdx", "!=", "-", "1", ")", "if", "(", "!", "commuteInstruction", "(", "UseMI", ",", "false", ",", "CommuteIdx", ",", "UseIdx", ")", ")", "return", "false", ";", "bool", "DeleteDef", "=", "MRI", "->", "hasOneNonDBGUse", "(", "Reg", ")", ";", "UseMI", ".", "setDesc", "(", "get", "(", "NewUseOpc", ")", ")", ";", "if", "(", "TieOps", ")", "UseMI", ".", "tieOperands", "(", "0", ",", "1", ")", ";", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ".", "ChangeToImmediate", "(", "ImmVal", ")", ";", "if", "(", "DeleteDef", ")", "DefMI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Reg", "is", "known", "to", "be", "defined", "by", "a", "move", "immediate", "instruction", ",", "try", "to", "fold", "the", "immediate", "into", "the", "use", "instruction", "." ]

[ "SystemZ", "SystemZ", "SystemZ::LHIMux", "SystemZ::LHI", "SystemZ::LGHI", "0", "1", "1", "SystemZ::SELRMux", "SystemZ::LOCRMux", "SystemZ::LOCHIMux", "2", "2", "1", "2", "1", "SystemZ::SELGR", "SystemZ::LOCGR", "SystemZ::LOCGHI", "2", "2", "1", "2", "1", "1", "0", "1" ]

[]

[ "<s>", "OperandMatchResultTy", "RISCVAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "RegNo", "=", "0", ";", "StringRef", "Name", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "if", "(", "matchRegisterNameHelper", "(", "isRV32E", "(", ")", ",", "(", "MCRegister", "&", ")", "RegNo", ",", "Name", ")", ")", "return", "MatchOperand_NoMatch", ";", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "M88kInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", ",", "0u", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "M88k", "M88k", "0u" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "initialize", "(", "MF", ")", ";", "return", "simplifyCode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "isConditionalBranch", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "Bcc", "&&", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "ARMCC", "::", "AL", ")", "return", "false", ";", "return", "MCInstrAnalysis", "::", "isConditionalBranch", "(", "Inst", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "branch", "which", "may", "fall", "through", "to", "the", "next", "instruction", "or", "may", "transfer", "control", "flow", "to", "some", "other", "block", "." ]

[ "ARM", "ARM::Bcc", "1", "ARMCC::AL" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "static", "tree", "mips_build_cvpointer_type", "(", "void", ")", "{", "static", "tree", "cache", ";", "if", "(", "cache", "==", "NULL_TREE", ")", "cache", "=", "build_pointer_type", "(", "build_qualified_type", "(", "void_type_node", ",", "TYPE_QUAL_CONST", "|", "TYPE_QUAL_VOLATILE", ")", ")", ";", "return", "cache", ";", "}", "</s>" ]

[ "Return", "a", "type", "for", "'const", "volatile", "void", "*", "'", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "mips_get_unaligned_mem", "(", "rtx", "op", ",", "HOST_WIDE_INT", "width", ",", "HOST_WIDE_INT", "bitpos", ",", "rtx", "*", "left", ",", "rtx", "*", "right", ")", "{", "rtx", "first", ",", "last", ";", "if", "(", "width", "!=", "32", "&&", "(", "!", "TARGET_64BIT", "||", "width", "!=", "64", ")", ")", "return", "false", ";", "if", "(", "bitpos", "%", "BITS_PER_UNIT", "!=", "0", ")", "return", "false", ";", "if", "(", "MEM_ALIGN", "(", "op", ")", ">=", "width", ")", "return", "false", ";", "first", "=", "adjust_address", "(", "op", ",", "QImode", ",", "0", ")", ";", "last", "=", "adjust_address", "(", "op", ",", "QImode", ",", "width", "/", "BITS_PER_UNIT", "-", "1", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "*", "left", "=", "first", ",", "*", "right", "=", "last", ";", "else", "*", "left", "=", "last", ",", "*", "right", "=", "first", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "use", "left/right", "accesses", "for", "a", "bitfield", "of", "WIDTH", "bits", "starting", "BITPOS", "bits", "into", "*", "OP", ".", "When", "returning", "true", ",", "update", "*", "OP", ",", "*", "LEFT", "and", "*", "RIGHT", "as", "follows", ":", "*", "OP", "is", "a", "BLKmode", "reference", "to", "the", "whole", "field", ".", "*", "LEFT", "is", "a", "QImode", "reference", "to", "the", "first", "byte", "if", "big", "endian", "or", "the", "last", "byte", "if", "little", "endian", ".", "This", "address", "can", "be", "used", "in", "the", "left-side", "instructions", "(", "lwl", ",", "swl", ",", "ldl", ",", "sdl", ")", ".", "*", "RIGHT", "is", "a", "QImode", "reference", "to", "the", "opposite", "end", "of", "the", "field", "and", "can", "be", "used", "in", "the", "patterning", "right-side", "instruction", "." ]

[ "mips", "32", "64", "0", "0", "1" ]

[]

[ "<s>", "bool", "AMDGPURegisterBankInfo", "::", "executeInWaterfallLoop", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "ArrayRef", "<", "unsigned", ">", "OpIndices", ")", "const", "{", "MachineIRBuilder", "B", "(", "MI", ")", ";", "return", "executeInWaterfallLoop", "(", "B", ",", "MI", ",", "MRI", ",", "OpIndices", ")", ";", "}", "</s>" ]

[ "Legalize", "instruction", "MI", "where", "operands", "in", "OpIndices", "must", "be", "SGPRs", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "XCorePassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "static", "rtx", "mips_legitimize_tls_address", "(", "rtx", "loc", ")", "{", "rtx", "dest", ",", "insn", ",", "v0", ",", "tp", ",", "tmp1", ",", "tmp2", ",", "eqv", ",", "offset", ";", "enum", "tls_model", "model", ";", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "loc", ")", ";", "if", "(", "!", "TARGET_ABICALLS", ")", "model", "=", "TLS_MODEL_LOCAL_EXEC", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "v0", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_RETURN", ")", ";", "insn", "=", "mips_call_tls_get_addr", "(", "loc", ",", "SYMBOL_TLSGD", ",", "v0", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insn", ",", "dest", ",", "v0", ",", "loc", ")", ";", "break", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "v0", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_RETURN", ")", ";", "insn", "=", "mips_call_tls_get_addr", "(", "loc", ",", "SYMBOL_TLSLDM", ",", "v0", ")", ";", "tmp1", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_TLS_LDM", ")", ";", "emit_libcall_block", "(", "insn", ",", "tmp1", ",", "v0", ",", "eqv", ")", ";", "offset", "=", "mips_unspec_address", "(", "loc", ",", "SYMBOL_DTPREL", ")", ";", "if", "(", "mips_split_p", "[", "SYMBOL_DTPREL", "]", ")", "{", "tmp2", "=", "mips_unspec_offset_high", "(", "NULL", ",", "tmp1", ",", "loc", ",", "SYMBOL_DTPREL", ")", ";", "dest", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmp2", ",", "offset", ")", ";", "}", "else", "dest", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "tmp1", ",", "offset", ",", "0", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "tp", "=", "mips_get_tp", "(", ")", ";", "tmp1", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "tmp2", "=", "mips_unspec_address", "(", "loc", ",", "SYMBOL_GOTTPREL", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_load_gotdi", "(", "tmp1", ",", "pic_offset_table_rtx", ",", "tmp2", ")", ")", ";", "else", "emit_insn", "(", "gen_load_gotsi", "(", "tmp1", ",", "pic_offset_table_rtx", ",", "tmp2", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "tmp1", ",", "tp", ")", ")", ";", "break", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "tmp1", "=", "mips_get_tp", "(", ")", ";", "offset", "=", "mips_unspec_address", "(", "loc", ",", "SYMBOL_TPREL", ")", ";", "if", "(", "mips_split_p", "[", "SYMBOL_TPREL", "]", ")", "{", "tmp2", "=", "mips_unspec_offset_high", "(", "NULL", ",", "tmp1", ",", "loc", ",", "SYMBOL_TPREL", ")", ";", "dest", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmp2", ",", "offset", ")", ";", "}", "else", "dest", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "tmp1", ",", "offset", ",", "0", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "dest", ";", "}", "</s>" ]

[ "Generate", "the", "code", "to", "access", "LOC", ",", "a", "thread", "local", "SYMBOL_REF", ".", "The", "return", "value", "will", "be", "a", "valid", "address", "and", "move_operand", "(", "either", "a", "REG", "or", "a", "LO_SUM", ")", "." ]

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

[]

[ "<s>", "static", "int", "thumb2_legitimate_index_p", "(", "machine_mode", "mode", ",", "rtx", "index", ",", "int", "strict_p", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "index", ")", ";", "if", "(", "TARGET_VFP_BASE", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1024", "&&", "INTVAL", "(", "index", ")", ">", "-", "256", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "VALID_IWMMXT_REG_MODE", "(", "mode", ")", ")", "{", "if", "(", "!", "TARGET_LDRD", "||", "mode", "!=", "DImode", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1024", "&&", "INTVAL", "(", "index", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "}", "if", "(", "TARGET_NEON", "&&", "VALID_NEON_QREG_MODE", "(", "mode", ")", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1016", "&&", "INTVAL", "(", "index", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "TARGET_NEON", "&&", "VALID_NEON_DREG_MODE", "(", "mode", ")", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1024", "&&", "INTVAL", "(", "index", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "index", ",", "strict_p", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", "return", "1", ";", "if", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", "{", "if", "(", "code", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "index", ")", ";", "if", "(", "TARGET_LDRD", ")", "return", "IN_RANGE", "(", "val", ",", "-", "1020", ",", "1020", ")", "&&", "(", "val", "&", "3", ")", "==", "0", ";", "else", "return", "IN_RANGE", "(", "val", ",", "-", "255", ",", "4095", "-", "4", ")", ";", "}", "else", "return", "0", ";", "}", "if", "(", "code", "==", "MULT", ")", "{", "rtx", "xiop0", "=", "XEXP", "(", "index", ",", "0", ")", ";", "rtx", "xiop1", "=", "XEXP", "(", "index", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xiop0", ",", "strict_p", ")", "&&", "thumb2_index_mul_operand", "(", "xiop1", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xiop1", ",", "strict_p", ")", "&&", "thumb2_index_mul_operand", "(", "xiop0", ")", ")", ")", ";", "}", "else", "if", "(", "code", "==", "ASHIFT", ")", "{", "rtx", "op", "=", "XEXP", "(", "index", ",", "1", ")", ";", "return", "(", "arm_address_register_rtx_p", "(", "XEXP", "(", "index", ",", "0", ")", ",", "strict_p", ")", "&&", "CONST_INT_P", "(", "op", ")", "&&", "INTVAL", "(", "op", ")", ">", "0", "&&", "INTVAL", "(", "op", ")", "<=", "3", ")", ";", "}", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "4096", "&&", "INTVAL", "(", "index", ")", ">", "-", "256", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "INDEX", "is", "a", "valid", "Thumb-2", "address", "index", "operand", "." ]

[ "arm", "1024", "256", "3", "0", "1024", "1024", "3", "0", "1016", "1024", "3", "0", "1024", "1024", "3", "0", "4", "1", "1020", "1020", "3", "0", "255", "4095", "4", "0", "0", "1", "1", "0", "0", "3", "4096", "256" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Sparc32", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "void", "alpha_output_filename", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "static", "int", "first_time", "=", "TRUE", ";", "if", "(", "first_time", ")", "{", "first_time", "=", "FALSE", ";", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "if", "(", "!", "TARGET_GAS", "&&", "write_symbols", "==", "DBX_DEBUG", ")", "fprintf", "(", "stream", ",", "\"\\t#@stabs\\n\"", ")", ";", "}", "else", "if", "(", "write_symbols", "==", "DBX_DEBUG", ")", "return", ";", "else", "if", "(", "name", "!=", "current_function_file", "&&", "strcmp", "(", "name", ",", "current_function_file", ")", "!=", "0", ")", "{", "if", "(", "inside_function", "&&", "!", "TARGET_GAS", ")", "fprintf", "(", "stream", ",", "\"\\t#.file\\t%d \"", ",", "num_source_filenames", ")", ";", "else", "{", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "}", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "new", "filename", "to", "a", "stream", "." ]

[ "alpha", "\"\\t.file\\t%d \"", "\"\\n\"", "\"\\t#@stabs\\n\"", "0", "\"\\t#.file\\t%d \"", "\"\\t.file\\t%d \"", "\"\\n\"" ]

[]

[ "<s>", "void", "machopic_output_stub", "(", "FILE", "*", "file", ",", "const", "char", "*", "symb", ",", "const", "char", "*", "stub", ")", "{", "unsigned", "int", "length", ";", "char", "*", "symbol_name", ",", "*", "lazy_ptr_name", ";", "char", "*", "local_label_0", ";", "static", "int", "label", "=", "0", ";", "symb", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "symb", ")", ";", "length", "=", "strlen", "(", "symb", ")", ";", "symbol_name", "=", "XALLOCAVEC", "(", "char", ",", "length", "+", "32", ")", ";", "GEN_SYMBOL_NAME_FOR_SYMBOL", "(", "symbol_name", ",", "symb", ",", "length", ")", ";", "lazy_ptr_name", "=", "XALLOCAVEC", "(", "char", ",", "length", "+", "32", ")", ";", "GEN_LAZY_PTR_NAME_FOR_SYMBOL", "(", "lazy_ptr_name", ",", "symb", ",", "length", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "switch_to_section", "(", "darwin_sections", "[", "machopic_picsymbol_stub1_section", "]", ")", ";", "else", "switch_to_section", "(", "darwin_sections", "[", "machopic_symbol_stub1_section", "]", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "{", "fprintf", "(", "file", ",", "\"\\t.align 5\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "label", "++", ";", "local_label_0", "=", "XALLOCAVEC", "(", "char", ",", "sizeof", "(", "\"\\\"L00000000000$spb\\\"\"", ")", ")", ";", "sprintf", "(", "local_label_0", ",", "\"\\\"L%011d$spb\\\"\"", ",", "label", ")", ";", "fprintf", "(", "file", ",", "\"\\tmflr r0\\n\"", ")", ";", "if", "(", "TARGET_LINK_STACK", ")", "{", "char", "name", "[", "32", "]", ";", "get_ppc476_thunk_name", "(", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\tbl %s\\n\"", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\\tmflr r11\\n\"", ",", "local_label_0", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\tbcl 20,31,%s\\n\"", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\\tmflr r11\\n\"", ",", "local_label_0", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\taddis r11,r11,ha16(%s-%s)\\n\"", ",", "lazy_ptr_name", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "\"\\tmtlr r0\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s r12,lo16(%s-%s)(r11)\\n\"", ",", "(", "TARGET_64BIT", "?", "\"ldu\"", ":", "\"lwzu\"", ")", ",", "lazy_ptr_name", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "\"\\tmtctr r12\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tbctr\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\t.align 4\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "\"\\tlis r11,ha16(%s)\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s r12,lo16(%s)(r11)\\n\"", ",", "(", "TARGET_64BIT", "?", "\"ldu\"", ":", "\"lwzu\"", ")", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\tmtctr r12\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tbctr\\n\"", ")", ";", "}", "switch_to_section", "(", "darwin_sections", "[", "machopic_lazy_symbol_ptr_section", "]", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "\"%sdyld_stub_binding_helper\\n\"", ",", "(", "TARGET_64BIT", "?", "DOUBLE_INT_ASM_OP", ":", "\"\\t.long\\t\"", ")", ")", ";", "}", "</s>" ]

[ "Generate", "external", "symbol", "indirection", "stubs", "(", "PIC", "and", "non-PIC", ")", "." ]

[ "powerpcspe", "0", "32", "32", "2", "2", "\"\\t.align 5\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\\"L00000000000$spb\\\"\"", "\"\\\"L%011d$spb\\\"\"", "\"\\tmflr r0\\n\"", "32", "\"\\tbl %s\\n\"", "\"%s:\\n\\tmflr r11\\n\"", "\"\\tbcl 20,31,%s\\n\"", "\"%s:\\n\\tmflr r11\\n\"", "\"\\taddis r11,r11,ha16(%s-%s)\\n\"", "\"\\tmtlr r0\\n\"", "\"\\t%s r12,lo16(%s-%s)(r11)\\n\"", "\"ldu\"", "\"lwzu\"", "\"\\tmtctr r12\\n\"", "\"\\tbctr\\n\"", "\"\\t.align 4\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\tlis r11,ha16(%s)\\n\"", "\"\\t%s r12,lo16(%s)(r11)\\n\"", "\"ldu\"", "\"lwzu\"", "\"\\tmtctr r12\\n\"", "\"\\tbctr\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"%sdyld_stub_binding_helper\\n\"", "\"\\t.long\\t\"" ]

[]

[ "<s>", "static", "unsigned", "rs6000_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "if", "(", "unroll_only_small_loops", ")", "{", "if", "(", "loop", "->", "ninsns", "<=", "6", ")", "return", "MIN", "(", "4", ",", "nunroll", ")", ";", "if", "(", "loop", "->", "ninsns", "<=", "10", ")", "return", "MIN", "(", "2", ",", "nunroll", ")", ";", "return", "0", ";", "}", "return", "nunroll", ";", "}", "</s>" ]

[ "Implement", "targetm.loop_unroll_adjust", "." ]

[ "rs6000", "6", "4", "10", "2", "0" ]

[]

[ "<s>", "int", "m32c_modes_tieable_p", "(", "machine_mode", "m1", ",", "machine_mode", "m2", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "m1", ")", "==", "GET_MODE_SIZE", "(", "m2", ")", ")", "return", "1", ";", "if", "(", "m1", "==", "QImode", "||", "m2", "==", "QImode", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Implements", "MODES_TIEABLE_P", ".", "In", "general", ",", "modes", "are", "n't", "tieable", "since", "registers", "are", "all", "different", "sizes", ".", "However", ",", "since", "most", "modes", "are", "bigger", "than", "our", "registers", "anyway", ",", "it", "'s", "easier", "to", "implement", "this", "function", "that", "way", ",", "leaving", "QImode", "as", "the", "only", "unique", "case", "." ]

[ "m32c", "1", "0", "1" ]

[]

[ "<s>", "static", "int", "ia32_multipass_dfa_lookahead", "(", "void", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "return", "2", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "case", "PROCESSOR_K6", ":", "return", "1", ";", "case", "PROCESSOR_BDVER1", ":", "case", "PROCESSOR_BDVER2", ":", "case", "PROCESSOR_BDVER3", ":", "case", "PROCESSOR_BDVER4", ":", "return", "4", ";", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "case", "PROCESSOR_BONNELL", ":", "case", "PROCESSOR_SILVERMONT", ":", "case", "PROCESSOR_KNL", ":", "case", "PROCESSOR_INTEL", ":", "if", "(", "reload_completed", ")", "return", "ix86_issue_rate", "(", ")", ";", "return", "0", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "How", "many", "alternative", "schedules", "to", "try", ".", "This", "should", "be", "as", "wide", "as", "the", "scheduling", "freedom", "in", "the", "DFA", ",", "but", "no", "wider", ".", "Making", "this", "value", "too", "large", "results", "extra", "work", "for", "the", "scheduler", "." ]

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

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "bool", "isPatchPoint", "=", "CLI", ".", "IsPatchPoint", ";", "ImmutableCallSite", "CS", "=", "CLI", ".", "CS", ";", "if", "(", "isTailCall", ")", "{", "if", "(", "Subtarget", ".", "useLongCalls", "(", ")", "&&", "!", "(", "CS", "&&", "CS", ".", "isMustTailCall", "(", ")", ")", ")", "isTailCall", "=", "false", ";", "else", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization_64SVR4", "(", "Callee", ",", "CallConv", ",", "CS", ",", "isVarArg", ",", "Outs", ",", "Ins", ",", "DAG", ")", ";", "else", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "isTailCall", ")", "{", "++", "NumTailCalls", ";", "if", "(", "!", "getTargetMachine", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "++", "NumSiblingCalls", ";", "assert", "(", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "&&", "\"Callee should be an llvm::Function object.\"", ")", ";", "DEBUG", "(", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "->", "getGlobal", "(", ")", ";", "const", "unsigned", "Width", "=", "80", "-", "strlen", "(", "\"TCO caller: \"", ")", "-", "strlen", "(", "\", callee linkage: 0, 0\"", ")", ";", "dbgs", "(", ")", "<<", "\"TCO caller: \"", "<<", "left_justify", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getName", "(", ")", ",", "Width", ")", "<<", "\", callee linkage: \"", "<<", "GV", "->", "getVisibility", "(", ")", "<<", "\", \"", "<<", "GV", "->", "getLinkage", "(", ")", "<<", "\"\\n\"", ")", ";", "}", "}", "if", "(", "!", "isTailCall", "&&", "CS", "&&", "CS", ".", "isMustTailCall", "(", ")", ")", "report_fatal_error", "(", "\"failed to perform tail call elimination on a call \"", "\"site marked musttail\"", ")", ";", "if", "(", "Subtarget", ".", "useLongCalls", "(", ")", "&&", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "&&", "!", "isTailCall", ")", "Callee", "=", "LowerGlobalAddress", "(", "Callee", ",", "DAG", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "isPatchPoint", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ",", "CS", ")", ";", "else", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "isPatchPoint", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ",", "CS", ")", ";", "}", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "isPatchPoint", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ",", "CS", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "ISD::InputArg", "PPC", "\"Callee should be an llvm::Function object.\"", "80", "\"TCO caller: \"", "\", callee linkage: 0, 0\"", "\"TCO caller: \"", "\", callee linkage: \"", "\", \"", "\"\\n\"", "\"failed to perform tail call elimination on a call \"", "\"site marked musttail\"", "PPC" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "*", "CmpInstr", ",", "unsigned", "SrcReg", ",", "unsigned", "SrcReg2", ",", "int", "CmpMask", ",", "int", "CmpValue", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "CmpInstr", ")", ";", "assert", "(", "CmpInstr", "->", "getParent", "(", ")", ")", ";", "assert", "(", "MRI", ")", ";", "int", "DeadNZCVIdx", "=", "CmpInstr", "->", "findRegisterDefOperandIdx", "(", "AArch64", "::", "NZCV", ",", "true", ")", ";", "if", "(", "DeadNZCVIdx", "!=", "-", "1", ")", "{", "if", "(", "CmpInstr", "->", "definesRegister", "(", "AArch64", "::", "WZR", ")", "||", "CmpInstr", "->", "definesRegister", "(", "AArch64", "::", "XZR", ")", ")", "{", "CmpInstr", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "unsigned", "Opc", "=", "CmpInstr", "->", "getOpcode", "(", ")", ";", "unsigned", "NewOpc", "=", "convertFlagSettingOpcode", "(", "CmpInstr", ")", ";", "if", "(", "NewOpc", "==", "Opc", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "NewOpc", ")", ";", "CmpInstr", "->", "setDesc", "(", "MCID", ")", ";", "CmpInstr", "->", "RemoveOperand", "(", "DeadNZCVIdx", ")", ";", "bool", "succeeded", "=", "UpdateOperandRegClass", "(", "CmpInstr", ")", ";", "(", "void", ")", "succeeded", ";", "assert", "(", "succeeded", "&&", "\"Some operands reg class are incompatible!\"", ")", ";", "return", "true", ";", "}", "if", "(", "CmpInstr", "->", "getOpcode", "(", ")", "==", "AArch64", "::", "PTEST_PP", ")", "return", "optimizePTestInstr", "(", "CmpInstr", ",", "SrcReg", ",", "SrcReg2", ",", "MRI", ",", "&", "getRegisterInfo", "(", ")", ",", "this", ")", ";", "assert", "(", "(", "CmpValue", "==", "0", "||", "CmpValue", "==", "1", ")", "&&", "\"CmpValue must be 0 or 1!\"", ")", ";", "if", "(", "CmpValue", "!=", "0", "||", "SrcReg2", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "use_nodbg_empty", "(", "CmpInstr", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "return", "substituteCmpToZero", "(", "CmpInstr", ",", "SrcReg", ",", "MRI", ")", ";", "}", "</s>" ]

[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]

[ "AArch64", "AArch64", "AArch64::NZCV", "1", "AArch64::WZR", "AArch64::XZR", "\"Some operands reg class are incompatible!\"", "AArch64::PTEST_PP", "0", "1", "\"CmpValue must be 0 or 1!\"", "0", "0", "0" ]

[]

[ "<s>", "static", "int", "mn10300_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "ifrom", ",", "reg_class_t", "ito", ")", "{", "enum", "reg_class", "from", "=", "(", "enum", "reg_class", ")", "ifrom", ";", "enum", "reg_class", "to", "=", "(", "enum", "reg_class", ")", "ito", ";", "enum", "reg_class", "scratch", ",", "test", ";", "if", "(", "to", "==", "FP_ACC_REGS", ")", "to", "=", "FP_REGS", ";", "if", "(", "from", "==", "FP_ACC_REGS", ")", "from", "=", "FP_REGS", ";", "scratch", "=", "NO_REGS", ";", "test", "=", "from", ";", "if", "(", "to", "==", "SP_REGS", ")", "scratch", "=", "(", "TARGET_AM33", "?", "GENERAL_REGS", ":", "ADDRESS_REGS", ")", ";", "else", "if", "(", "to", "==", "MDR_REGS", ")", "scratch", "=", "DATA_REGS", ";", "else", "if", "(", "to", "==", "FP_REGS", "&&", "to", "!=", "from", ")", "scratch", "=", "GENERAL_REGS", ";", "else", "{", "test", "=", "to", ";", "if", "(", "from", "==", "SP_REGS", ")", "scratch", "=", "(", "TARGET_AM33", "?", "GENERAL_REGS", ":", "ADDRESS_REGS", ")", ";", "else", "if", "(", "from", "==", "MDR_REGS", ")", "scratch", "=", "DATA_REGS", ";", "else", "if", "(", "from", "==", "FP_REGS", "&&", "to", "!=", "from", ")", "scratch", "=", "GENERAL_REGS", ";", "}", "if", "(", "scratch", "!=", "NO_REGS", "&&", "!", "reg_class_subset_p", "(", "test", ",", "scratch", ")", ")", "return", "(", "mn10300_register_move_cost", "(", "VOIDmode", ",", "from", ",", "scratch", ")", "+", "mn10300_register_move_cost", "(", "VOIDmode", ",", "scratch", ",", "to", ")", ")", ";", "if", "(", "optimize_size", ")", "{", "if", "(", "from", "==", "to", "&&", "(", "to", "==", "ADDRESS_REGS", "||", "to", "==", "DATA_REGS", ")", ")", "return", "2", ";", "if", "(", "from", "==", "SP_REGS", ")", "return", "(", "to", "==", "ADDRESS_REGS", "?", "2", ":", "6", ")", ";", "if", "(", "TARGET_AM33", ")", "return", "4", ";", "if", "(", "to", "==", "SP_REGS", ")", "return", "(", "from", "==", "ADDRESS_REGS", "?", "4", ":", "6", ")", ";", "if", "(", "(", "from", "==", "ADDRESS_REGS", "||", "from", "==", "DATA_REGS", ")", "&&", "(", "to", "==", "ADDRESS_REGS", "||", "to", "==", "DATA_REGS", ")", ")", "return", "4", ";", "if", "(", "to", "==", "EXTENDED_REGS", ")", "return", "(", "to", "==", "from", "?", "6", ":", "4", ")", ";", "return", "6", ";", "}", "else", "{", "if", "(", "to", "==", "FP_REGS", ")", "return", "8", ";", "if", "(", "from", "==", "FP_REGS", ")", "return", "4", ";", "return", "2", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_REGISTER_MOVE_COST", "hook", ".", "Recall", "that", "the", "base", "value", "of", "2", "is", "required", "by", "assumptions", "elsewhere", "in", "the", "body", "of", "the", "compiler", ",", "and", "that", "cost", "2", "is", "special-cased", "as", "an", "early", "exit", "from", "reload", "meaning", "no", "work", "is", "required", "." ]

[ "mn10300", "2", "2", "6", "4", "4", "6", "4", "6", "4", "6", "8", "4", "2" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "unsigned", "Directive", "=", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "Directive", ")", "{", "default", ":", "Opcode", "=", "PPC", "::", "NOP", ";", "break", ";", "case", "PPC", "::", "DIR_PWR6", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR6", ";", "break", ";", "case", "PPC", "::", "DIR_PWR7", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "}", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::NOP", "PPC::DIR_PWR6", "PPC::NOP_GT_PWR6", "PPC::DIR_PWR7", "PPC::NOP_GT_PWR7" ]

[]