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

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

2 #include <linux/compiler.h>

static int s390_call__parse(struct arch *arch, struct ins_operands *ops,

5 struct map_symbol *ms)

6 {

        char *endptr, *tok, *name;

        struct map *map = ms->map;

9 struct addr_map_symbol target = {

10 .ms = { .map = map, },

11 };

        tok = strchr(ops->raw, ',');

14 if (!tok)

15 return -1;

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

        name = strchr(endptr, '<');

20 if (name == NULL)

21 return -1;

23 name++;

        if (arch->objdump.skip_functions_char &&

            strchr(name, arch->objdump.skip_functions_char))

27 return -1;

        tok = strchr(name, '>');

30 if (tok == NULL)

31 return -1;

33 *tok = '\0';

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

35 *tok = '>';

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

38 return -1;

        target.addr = map__objdump_2mem(map, ops->target.addr);

        if (maps__find_ams(ms->maps, &target) == 0 &&

            map__rip_2objdump(target.ms.map, map->map_ip(target.ms.map, target.addr)) == ops->target.addr)

                ops->target.sym = target.ms.sym;

45 return 0;

46 }

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

                           struct ins_operands *ops, int max_ins_name);

51 static struct ins_ops s390_call_ops = {

52 .parse = s390_call__parse,

53 .scnprintf = call__scnprintf,

54 };

static int s390_mov__parse(struct arch *arch __maybe_unused,

57 struct ins_operands *ops,

58 struct map_symbol *ms __maybe_unused)

59 {

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

62 if (s == NULL)

63 return -1;

65 *s = '\0';

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

67 *s = ',';

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

70 return -1;

72 target = ++s;

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

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

75 goto out_free_source;

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

78 if (endptr == target)

79 goto out_free_target;

        s = strchr(endptr, '<');

82 if (s == NULL)

83 goto out_free_target;

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

85 if (endptr == NULL)

86 goto out_free_target;

88 *endptr = '\0';

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

90 *endptr = '>';

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

92 goto out_free_target;

94 return 0;

96 out_free_target:

        zfree(&ops->target.raw);

98 out_free_source:

        zfree(&ops->source.raw);

100 return -1;

101 }

102

103

104 static struct ins_ops s390_mov_ops = {

105 .parse = s390_mov__parse,

106 .scnprintf = mov__scnprintf,

107 };

108

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

110 {

111 struct ins_ops *ops = NULL;

112

113 /* catch all kind of jumps */

        if (strchr(name, 'j') ||

            !strncmp(name, "bct", 3) ||

            !strncmp(name, "br", 2))

117 ops = &jump_ops;

118 /* override call/returns */

        if (!strcmp(name, "bras") ||

            !strcmp(name, "brasl") ||

            !strcmp(name, "basr"))

122 ops = &s390_call_ops;

        if (!strcmp(name, "br"))

124 ops = &ret_ops;

125 /* override load/store relative to PC */

        if (!strcmp(name, "lrl") ||

            !strcmp(name, "lgrl") ||

            !strcmp(name, "lgfrl") ||

            !strcmp(name, "llgfrl") ||

            !strcmp(name, "strl") ||

            !strcmp(name, "stgrl"))

132 ops = &s390_mov_ops;

133

134 if (ops)

                arch__associate_ins_ops(arch, name, ops);

136 return ops;

137 }

138

static int s390__cpuid_parse(struct arch *arch, char *cpuid)

140 {

141 unsigned int family;

        char model[16], model_c[16], cpumf_v[16], cpumf_a[16];

143 int ret;

144

145 /*

146 * cpuid string format:

147 * "IBM,family,model-capacity,model[,cpum_cf-version,cpum_cf-authorization]"

148 */

        ret = sscanf(cpuid, "%*[^,],%u,%[^,],%[^,],%[^,],%s", &family, model_c,

150 model, cpumf_v, cpumf_a);

        if (ret >= 2) {

152 arch->family = family;

153 arch->model = 0;

154 return 0;

155 }

156

157 return -1;

158 }

159

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

161 {

162 int err = 0;

163

164 if (!arch->initialized) {

165 arch->initialized = true;

166 arch->associate_instruction_ops = s390__associate_ins_ops;

167 if (cpuid) {

                        if (s390__cpuid_parse(arch, cpuid))

169 err = SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_CPUID_PARSING;

170 }

171 }

172

173 return err;

174 }