| dbo:abstract
|
- En construction de compilateur, la signature (aussi appelée décoration de nom) est une technique utilisée pour résoudre divers problèmes de résolution de noms uniques des avec plusieurs langages de programmation modernes. Cette technique fournit un moyen d'encoder des informations supplémentaires dans le nom d'une , d'une classe ou d'un autre type de donnée afin que les compilateurs puissent communiquer davantage d'informations sémantiques aux lieurs. Cette technique est utile lorsque le langage de programmation permet à différentes entités d'utiliser le même identifiant tant qu'ils occupent différents espace de noms (un espace de noms est typiquement défini par un module, une classe ou une instruction explicite de déclaration d'espace de noms) ou qu'ils ont des signatures différentes (par exemple. avec la surcharge de fonction). Cette utilisation est nécessaire parce que chaque signature peut exiger une convention d'appel spécialisée dans le code machine. Tout code objet produit par un compilateur est lié avec d'autres codes objets (produits par le même compilateur ou par un autre) par un programme appelé lieur (ou éditeur de liens) qui a besoin de nombreuses informations concernant chaque entité. Par exemple, pour lier correctement une routine, il faut son identifiant (nom) le nombre d'arguments, leurs types, etc. Les langages de programmation simples des années 1970 (par exemple, le langage C) distinguent seulement les bouts de code par leur identifiant, ignorant les autres informations tels que les types des paramètres et le type de la . Les langage de programmation plus récents (par exemple, le langage C++) définissent des exigences plus strictes pour les bouts de code afin de les considérer équivalents, tels que les types des paramètres, le type de la valeur retournée et la convention d'appel de la routine. Ces exigences permettent la surcharge de routine aussi bien que la détection de divers bogue (tel l'utilisation de différentes définitions de routine pour compiler différents fichiers sources). Ces exigences plus strictes doivent fonctionner avec les outils et les conventions existants, ce qui implique que les exigences supplémentaires doivent être encodées dans le nom du symbole puisque c'est la seule information qu'un lieur traditionnel dispose concernant un symbole. Cette façon d'encoder des informations supplémentaires dans l'identifiant, souvent appelée « obsession primaire », considéré comme un anti-modèle, a tout de même été établi comme la norme. La décoration de nom permet aussi de détecter des modifications supplémentaires non reliées à la signature (tels que la pureté de la routine, la lever potentielle d'une exception ou le lancement du Ramasse-miettes)). Par exemple, le langage D fonctionne ainsi. La décoration de nom est davantage qu'une simple vérification d'erreur. Par exemple, la routine int f; et la routine pure int g(int); peuvent être compilées dans des fichiers objets séparés, mais alors leurs signatures deviennent float f; et int g(int), ces dernières sont utilisées pour compiler d'autres codes sources qui les appellent. Lors de l'édition des liens, le lieur détecte qu'il n'y a pas de routine f(int) et ne génère pas le code exécutable. De même, le lieur n'est pas en mesure de déterminer que le type de la valeur retournée de f est différent et qu'il ne faut pas générer le code exécutable (une convention d'appel non compatible sera utilisée et produira probablement un code défectueux résultat ou fera planter le programme). La décoration de nom ne contient pas tous les détails du processus d'appel. Ainsi, elle ne peut prévenir complètement les erreurs tel que la modification des membres données (propriétés) d'une structures de données ou d'une classe. Par exemple, struct S {}; void f(S) {} peut être compilé dans un même code objet, la déclaration de S devenant struct S { int x; }; qui sera utilisé pour la compilation de l'appel f(S). Dans une telle situation, le compilateur utilise habituellement différentes conventions d'appel, mais f aura le même nom décoré dans ces deux cas, le lieur ne pourra donc détecter le problème, ce qui résultera en un plantage, une corruption des données ou de mémoire lors de l'exécution du programme. (fr)
- In compiler construction, name mangling (also called name decoration) is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages. It provides a way of encoding additional information in the name of a function, structure, class or another datatype in order to pass more semantic information from the compiler to the linker. The need for name mangling arises where the language allows different entities to be named with the same identifier as long as they occupy a different namespace (typically defined by a module, class, or explicit namespace directive) or have different signatures (such as in function overloading). It is required in these use cases because each signature might require different, specialized calling convention in the machine code. Any object code produced by compilers is usually linked with other pieces of object code (produced by the same or another compiler) by a type of program called a linker. The linker needs a great deal of information on each program entity. For example, to correctly link a function it needs its name, the number of arguments and their types, and so on. The simple programming languages of the 1970s, like C, only distinguished subroutines by their name, ignoring other information including parameter and return types.Later programming languages, like C++, defined stricter requirements for routines to be considered "equal", such as the parameter types, return type, and calling convention of a function. These requirements enable method overloading and detection of some bugs (such as using different definitions of a function when compiling different source files).These stricter requirements needed to work with existing tools and conventions; therefore, additional requirements were encoded in the name of the symbol, since that was the only information the traditional linker had about a symbol. Another use of name mangling is for detecting additional non-signature related changes, such as function purity, or whether it can potentially throw an exception or trigger garbage collection. An example of a language doing this is D. These are more of a simplified error checking. For example, functions int f; and int g(int) pure; could be compiled into one object file, but then their signatures changed to float f; int g(int); and used to compile other source calling it. At link time the linker will detect there is no function f(int) and return an error. Similarly, the linker will not be able to detect that the return type of f is different, and return an error. Otherwise, incompatible calling conventions would be used, and most likely produce the wrong result or crash the program. Mangling doesn't usually capture every detail of the calling process. For example, it doesn't fully prevent errors like changes of data members of a struct or class. For example, struct S {}; void f(S) {} could be compiled into one object file, then the definition for S changed to be struct S { int x; }; and used in the compilation of a call to f(S). In such cases, the compiler will usually use a different calling convention, but in both cases f will mangle to the same name, so the linker will not detect this problem, and the result will usually be a crash or data- or memory corruption at runtime. (en)
- 名前修飾（なまえしゅうしょく、英: name mangling）は、現代的なコンピュータプログラミング言語処理系で用いられている手法で、サブルーチン（関数）名などに対する内部名を、その表層的な名前のみならず、関数であればその引数の型や返戻値の型などといった意味的な情報を含めて修飾した（manglingした）名前とするものである。コンパイラからリンカ、さらには実行時のデバッガなども含んだシステム全体が、高度な型に関する情報などをサポートするように再実装するには多くの難しさがあるが、この手法であれば、システムの多くの部分ではわずかな修正（たとえば、名前に '$' という文字が含まれることを許すようにする、など）で済む。特に、多重定義（オーバーロード）を許す言語では、同一の表層名に対して許される多重定義や、その同定について上手に修飾を設計すれば、扱いが単純になる。また、そのままではエラーメッセージ等が読み辛いものとなるが、「解読」ルーチンを呼ぶように修正するだけで、型の情報などが付加された、むしろわかりやすいメッセージが出力されるようになる。 (ja)
- 컴파일러 구조에서 네임 맹글링(name mangling)은 현대의 수많은 프로그래밍 언어에서 프로그래밍 엔티티의 고유한 이름을 사용할 때 발생하는 다양한 문제를 해결하기 위해 사용되는 기법이다. 컴파일러로부터 링커로 더 시맨틱한 정보를 전달하기 위해 함수, 구조, 클래스 또는 다른 자료형의 이름에서 추가 정보를 인코딩하는 한 수단을 제공한다. (ko)
- Dekorowanie nazw (ang. name mangling, name decoration) – technika stosowana przez kompilatory współczesnych języków programowania w celu wygenerowania unikatowych nazw funkcji, struktur, klas oraz innych typów danych. Schemat generowania unikalnych nazw różni się w zależności od tego jaki kompilator został zastosowany. (pl)
- 名字修饰（name decoration），也称为名字重整、名字改编（name mangling），是现代计算机程序设计语言的编译器用于解决由于程序实体的名字必须唯一而导致的问题的一种技术。 它提供了在函数、结构体、类或其它的数据类型的名字中编码附加信息一种方法，用于从编译器中向链接器传递更多语义信息。 该需求产生于程序设计语言允许不同的条目使用相同的标识符，包括它们占据不同的命名空间（典型的命名空间是由一个模块、一个类或显式的namespace指示来定义的）或者有不同的签名（例如函数重载）。 任何由编译器产生的目标代码通常与另一部分的目标代码（产生于同一款或不同款的编译器）通过链接器把它们链接起来。链接器需要一大堆每个程序实体信息。例如正确链接一个函数需要它的名字、参数个数和它们的类型，等等。 (zh)
|
