Public Git Hosting - linux/fpc-iii.git/blob - tools/perf/arch/arm64/annotate/instructions.c

1 // SPDX-License-Identifier: GPL-2.0

2 #include <linux/compiler.h>

3 #include <sys/types.h>

4 #include <regex.h>

5 #include <stdlib.h>

7 struct arm64_annotate {

8 regex_t call_insn,

9 jump_insn;

10 };

static int arm64_mov__parse(struct arch *arch __maybe_unused,

13 struct ins_operands *ops,

14 struct map_symbol *ms __maybe_unused)

15 {

        char *s = strchr(ops->raw, ','), *target, *endptr;

18 if (s == NULL)

19 return -1;

21 *s = '\0';

        ops->source.raw = strdup(ops->raw);

23 *s = ',';

        if (ops->source.raw == NULL)

26 return -1;

28 target = ++s;

        ops->target.raw = strdup(target);

        if (ops->target.raw == NULL)

31 goto out_free_source;

        ops->target.addr = strtoull(target, &endptr, 16);

34 if (endptr == target)

35 goto out_free_target;

        s = strchr(endptr, '<');

38 if (s == NULL)

39 goto out_free_target;

        endptr = strchr(s + 1, '>');

41 if (endptr == NULL)

42 goto out_free_target;

44 *endptr = '\0';

45 *s = ' ';

        ops->target.name = strdup(s);

47 *s = '<';

48 *endptr = '>';

        if (ops->target.name == NULL)

50 goto out_free_target;

52 return 0;

54 out_free_target:

        zfree(&ops->target.raw);

56 out_free_source:

        zfree(&ops->source.raw);

58 return -1;

59 }

static int mov__scnprintf(struct ins *ins, char *bf, size_t size,

                          struct ins_operands *ops, int max_ins_name);

64 static struct ins_ops arm64_mov_ops = {

65 .parse = arm64_mov__parse,

66 .scnprintf = mov__scnprintf,

67 };

static struct ins_ops *arm64__associate_instruction_ops(struct arch *arch, const char *name)

70 {

        struct arm64_annotate *arm = arch->priv;

72 struct ins_ops *ops;

73 regmatch_t match[2];

        if (!regexec(&arm->jump_insn, name, 2, match, 0))

76 ops = &jump_ops;

        else if (!regexec(&arm->call_insn, name, 2, match, 0))

78 ops = &call_ops;

        else if (!strcmp(name, "ret"))

80 ops = &ret_ops;

81 else

82 ops = &arm64_mov_ops;

        arch__associate_ins_ops(arch, name, ops);

85 return ops;

86 }

static int arm64__annotate_init(struct arch *arch, char *cpuid __maybe_unused)

89 {

90 struct arm64_annotate *arm;

91 int err;

93 if (arch->initialized)

94 return 0;

        arm = zalloc(sizeof(*arm));

97 if (!arm)

98 return ENOMEM;

100 /* bl, blr */

        err = regcomp(&arm->call_insn, "^blr?$", REG_EXTENDED);

102 if (err)

103 goto out_free_arm;

104 /* b, b.cond, br, cbz/cbnz, tbz/tbnz */

        err = regcomp(&arm->jump_insn, "^[ct]?br?\\.?(cc|cs|eq|ge|gt|hi|le|ls|lt|mi|ne|pl)?n?z?$",

106 REG_EXTENDED);

107 if (err)

108 goto out_free_call;

109

110 arch->initialized = true;

111 arch->priv = arm;

112 arch->associate_instruction_ops = arm64__associate_instruction_ops;

        arch->objdump.comment_char        = '/';

        arch->objdump.skip_functions_char = '+';

115 return 0;

116

117 out_free_call:

118 regfree(&arm->call_insn);

119 out_free_arm:

120 free(arm);

121 return SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_REGEXP;

122 }