jdk

1
/*
2
 * Copyright (c) 2005, 2023, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 *
23
 */
24

25
#include "precompiled.hpp"
26
#include "classfile/classFileParser.hpp"
27
#include "classfile/stackMapTable.hpp"
28
#include "classfile/verifier.hpp"
29
#include "classfile/vmSymbols.hpp"
30
#include "memory/resourceArea.hpp"
31

32
// Keep these in a separate file to prevent inlining
33

34
PRAGMA_DIAG_PUSH
35
PRAGMA_FORMAT_NONLITERAL_IGNORED
36

37
void ClassFileParser::classfile_parse_error(const char* msg, TRAPS) const {
38
  assert(_class_name != nullptr, "invariant");
39
  ResourceMark rm(THREAD);
40
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_ClassFormatError(),
41
                     msg, _class_name->as_C_string());
42
}
43

44
void ClassFileParser::classfile_parse_error(const char* msg,
45
                                            int index,
46
                                            TRAPS) const {
47
  assert(_class_name != nullptr, "invariant");
48
  ResourceMark rm(THREAD);
49
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_ClassFormatError(),
50
                     msg, index, _class_name->as_C_string());
51
}
52

53
void ClassFileParser::classfile_parse_error(const char* msg,
54
                                            const char* name,
55
                                            TRAPS) const {
56
  assert(_class_name != nullptr, "invariant");
57
  ResourceMark rm(THREAD);
58
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_ClassFormatError(),
59
                     msg, name, _class_name->as_C_string());
60
}
61

62
void ClassFileParser::classfile_parse_error(const char* msg,
63
                                            int index,
64
                                            const char* name,
65
                                            TRAPS) const {
66
  assert(_class_name != nullptr, "invariant");
67
  ResourceMark rm(THREAD);
68
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_ClassFormatError(),
69
                     msg, index, name, _class_name->as_C_string());
70
}
71

72
void ClassFileParser::classfile_parse_error(const char* msg,
73
                                            const char* name,
74
                                            const char* signature,
75
                                            TRAPS) const {
76
  assert(_class_name != nullptr, "invariant");
77
  ResourceMark rm(THREAD);
78
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_ClassFormatError(),
79
                     msg, name, signature, _class_name->as_C_string());
80
}
81

82
void ClassFileParser::classfile_icce_error(const char* msg,
83
                                           const Klass* k,
84
                                           TRAPS) const {
85
  assert(_class_name != nullptr, "invariant");
86
  ResourceMark rm(THREAD);
87
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_IncompatibleClassChangeError(),
88
                     msg, _class_name->as_klass_external_name(), k->external_name());
89
}
90

91
void ClassFileParser::classfile_ucve_error(const char* msg,
92
                                           const Symbol* class_name,
93
                                           u2 major,
94
                                           u2 minor,
95
                                           TRAPS) const {
96
  ResourceMark rm(THREAD);
97
  Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::java_lang_UnsupportedClassVersionError(),
98
                     msg, class_name->as_C_string(), major, minor);
99
}
100

101
PRAGMA_DIAG_POP
102

103
void StackMapStream::stackmap_format_error(const char* msg, TRAPS) {
104
  ResourceMark rm(THREAD);
105
  Exceptions::fthrow(
106
    THREAD_AND_LOCATION,
107
    vmSymbols::java_lang_ClassFormatError(),
108
    "StackMapTable format error: %s", msg
109
  );
110
}
111